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

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

kim_interactions V

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

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


mass          1 ${mass_converted}
mass          1 50.9415

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 27848.1293284656 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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_072444764353_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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -10524.253     -10524.253     -10600         -10600          293.15         293.15         27848.129      27848.129      2905.2975      2905.2975    
      1000  -10441.936     -10441.936     -10524.37      -10524.37       319.02842      319.02842      28071.88       28071.88      -1745.9981     -1745.9981    
Loop time of 95.4531 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.905 ns/day, 26.515 hours/ns, 10.476 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    | 94.969     | 94.969     | 94.969     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076597   | 0.076597   | 0.076597   |   0.0 |  0.08
Output  | 0.0002117  | 0.0002117  | 0.0002117  |   0.0 |  0.00
Modify  | 0.35047    | 0.35047    | 0.35047    |   0.0 |  0.37
Other   |            | 0.05641    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116000 ave      116000 max      116000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116000
Ave neighs/atom = 58
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -10441.936     -10441.936     -10524.37      -10524.37       319.02842      319.02842      28071.88       28071.88      -1745.9981     -1745.9981    
      2000  -10445.498     -10445.498     -10522.402     -10522.402      297.6259       297.6259       28054.566      28054.566     -715.35567     -715.35567    
Loop time of 100.274 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.862 ns/day, 27.854 hours/ns, 9.973 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    | 99.785     | 99.785     | 99.785     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078913   | 0.078913   | 0.078913   |   0.0 |  0.08
Output  | 0.0002688  | 0.0002688  | 0.0002688  |   0.0 |  0.00
Modify  | 0.35194    | 0.35194    | 0.35194    |   0.0 |  0.35
Other   |            | 0.05765    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3124 ave        3124 max        3124 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118764 ave      118764 max      118764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118764
Ave neighs/atom = 59.382
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -10445.498     -10445.498     -10522.402     -10522.402      297.6259       297.6259       28054.566      28054.566     -715.35567     -715.35567    
      3000  -10444.925     -10444.925     -10520.228     -10520.228      291.4311       291.4311       28010.364      28010.364      1795.3195      1795.3195    
Loop time of 100.117 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.863 ns/day, 27.810 hours/ns, 9.988 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    | 99.631     | 99.631     | 99.631     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078144   | 0.078144   | 0.078144   |   0.0 |  0.08
Output  | 0.00020469 | 0.00020469 | 0.00020469 |   0.0 |  0.00
Modify  | 0.34919    | 0.34919    | 0.34919    |   0.0 |  0.35
Other   |            | 0.05823    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3114 ave        3114 max        3114 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118880 ave      118880 max      118880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118880
Ave neighs/atom = 59.44
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -10444.925     -10444.925     -10520.228     -10520.228      291.4311       291.4311       28010.364      28010.364      1795.3195      1795.3195    
      4000  -10444.653     -10444.653     -10517.221     -10517.221      280.84292      280.84292      28041.006      28041.006      175.70835      175.70835    
Loop time of 100.801 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.857 ns/day, 28.000 hours/ns, 9.921 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    | 100.31     | 100.31     | 100.31     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07972    | 0.07972    | 0.07972    |   0.0 |  0.08
Output  | 0.00023152 | 0.00023152 | 0.00023152 |   0.0 |  0.00
Modify  | 0.3529     | 0.3529     | 0.3529     |   0.0 |  0.35
Other   |            | 0.05808    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3166 ave        3166 max        3166 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119066 ave      119066 max      119066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119066
Ave neighs/atom = 59.533
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -10444.653     -10444.653     -10517.221     -10517.221      280.84292      280.84292      28041.006      28041.006      175.70835      175.70835    
      5000  -10443.727     -10443.727     -10520.825     -10520.825      298.37669      298.37669      28088.211      28088.211     -2259.2708     -2259.2708    
Loop time of 102.873 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.840 ns/day, 28.576 hours/ns, 9.721 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    | 102.37     | 102.37     | 102.37     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080142   | 0.080142   | 0.080142   |   0.0 |  0.08
Output  | 0.0001827  | 0.0001827  | 0.0001827  |   0.0 |  0.00
Modify  | 0.36315    | 0.36315    | 0.36315    |   0.0 |  0.35
Other   |            | 0.05882    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3148 ave        3148 max        3148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119040 ave      119040 max      119040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119040
Ave neighs/atom = 59.52
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 295.073483476589, Press = -353.998544995283
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -10443.727     -10443.727     -10520.825     -10520.825      298.37669      298.37669      28088.211      28088.211     -2259.2708     -2259.2708    
      6000  -10443.588     -10443.588     -10519.735     -10519.735      294.6964       294.6964       27980.109      27980.109      3506.5507      3506.5507    
Loop time of 103.038 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.622 hours/ns, 9.705 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    | 102.51     | 102.51     | 102.51     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08063    | 0.08063    | 0.08063    |   0.0 |  0.08
Output  | 0.00016702 | 0.00016702 | 0.00016702 |   0.0 |  0.00
Modify  | 0.38585    | 0.38585    | 0.38585    |   0.0 |  0.37
Other   |            | 0.05887    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3123 ave        3123 max        3123 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118872 ave      118872 max      118872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118872
Ave neighs/atom = 59.436
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.637125357236, Press = -13.5673134924924
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -10443.588     -10443.588     -10519.735     -10519.735      294.6964       294.6964       27980.109      27980.109      3506.5507      3506.5507    
      7000  -10444.658     -10444.658     -10518.935     -10518.935      287.45787      287.45787      28043.895      28043.895     -101.34253     -101.34253    
Loop time of 103.535 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.835 ns/day, 28.760 hours/ns, 9.659 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    | 103.01     | 103.01     | 103.01     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081107   | 0.081107   | 0.081107   |   0.0 |  0.08
Output  | 0.00020544 | 0.00020544 | 0.00020544 |   0.0 |  0.00
Modify  | 0.3892     | 0.3892     | 0.3892     |   0.0 |  0.38
Other   |            | 0.05934    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3138 ave        3138 max        3138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118970 ave      118970 max      118970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118970
Ave neighs/atom = 59.485
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 291.812837808212, Press = 31.7464994588458
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -10444.658     -10444.658     -10518.935     -10518.935      287.45787      287.45787      28043.895      28043.895     -101.34253     -101.34253    
      8000  -10447.848     -10447.848     -10521.434     -10521.434      284.78581      284.78581      28056.676      28056.676     -1034.6559     -1034.6559    
Loop time of 103.902 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.862 hours/ns, 9.624 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    | 103.37     | 103.37     | 103.37     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081546   | 0.081546   | 0.081546   |   0.0 |  0.08
Output  | 0.00016264 | 0.00016264 | 0.00016264 |   0.0 |  0.00
Modify  | 0.38897    | 0.38897    | 0.38897    |   0.0 |  0.37
Other   |            | 0.05909    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3139 ave        3139 max        3139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118870 ave      118870 max      118870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118870
Ave neighs/atom = 59.435
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 291.922855674526, Press = -3.29214437307998
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -10447.848     -10447.848     -10521.434     -10521.434      284.78581      284.78581      28056.676      28056.676     -1034.6559     -1034.6559    
      9000  -10444.05      -10444.05      -10518.13      -10518.13       286.69753      286.69753      28007.955      28007.955      1836.4338      1836.4338    
Loop time of 103.242 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.837 ns/day, 28.678 hours/ns, 9.686 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    | 102.72     | 102.72     | 102.72     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08025    | 0.08025    | 0.08025    |   0.0 |  0.08
Output  | 0.00021035 | 0.00021035 | 0.00021035 |   0.0 |  0.00
Modify  | 0.38538    | 0.38538    | 0.38538    |   0.0 |  0.37
Other   |            | 0.05939    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3110 ave        3110 max        3110 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118872 ave      118872 max      118872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118872
Ave neighs/atom = 59.436
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.336387865304, Press = 4.16393806188034
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -10444.05      -10444.05      -10518.13      -10518.13       286.69753      286.69753      28007.955      28007.955      1836.4338      1836.4338    
     10000  -10444.176     -10444.176     -10519.086     -10519.086      289.90906      289.90906      28047.11       28047.11      -351.63097     -351.63097    
Loop time of 102.626 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.842 ns/day, 28.507 hours/ns, 9.744 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    | 102.1      | 102.1      | 102.1      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080288   | 0.080288   | 0.080288   |   0.0 |  0.08
Output  | 0.00016397 | 0.00016397 | 0.00016397 |   0.0 |  0.00
Modify  | 0.38242    | 0.38242    | 0.38242    |   0.0 |  0.37
Other   |            | 0.05874    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3152 ave        3152 max        3152 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119094 ave      119094 max      119094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119094
Ave neighs/atom = 59.547
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.686231980727, Press = 14.7679733489926
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -10444.176     -10444.176     -10519.086     -10519.086      289.90906      289.90906      28047.11       28047.11      -351.63097     -351.63097    
     11000  -10443.753     -10443.753     -10522.233     -10522.233      303.72825      303.72825      28092.141      28092.141     -2807.8363     -2807.8363    
Loop time of 104.043 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.901 hours/ns, 9.611 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    | 103.52     | 103.52     | 103.52     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08066    | 0.08066    | 0.08066    |   0.0 |  0.08
Output  | 0.00016543 | 0.00016543 | 0.00016543 |   0.0 |  0.00
Modify  | 0.38474    | 0.38474    | 0.38474    |   0.0 |  0.37
Other   |            | 0.05886    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3117 ave        3117 max        3117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118930 ave      118930 max      118930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118930
Ave neighs/atom = 59.465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.132197232892, Press = -8.61158923275921
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -10443.753     -10443.753     -10522.233     -10522.233      303.72825      303.72825      28092.141      28092.141     -2807.8363     -2807.8363    
     12000  -10446.397     -10446.397     -10523.07      -10523.07       296.72983      296.72983      27987.913      27987.913      2573.6476      2573.6476    
Loop time of 102.895 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.840 ns/day, 28.582 hours/ns, 9.719 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    | 102.37     | 102.37     | 102.37     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080974   | 0.080974   | 0.080974   |   0.0 |  0.08
Output  | 0.00016443 | 0.00016443 | 0.00016443 |   0.0 |  0.00
Modify  | 0.38497    | 0.38497    | 0.38497    |   0.0 |  0.37
Other   |            | 0.05895    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3147 ave        3147 max        3147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118776 ave      118776 max      118776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118776
Ave neighs/atom = 59.388
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.986129067239, Press = 1.43536745548123
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -10446.397     -10446.397     -10523.07      -10523.07       296.72983      296.72983      27987.913      27987.913      2573.6476      2573.6476    
     13000  -10442.224     -10442.224     -10518.04      -10518.04       293.41474      293.41474      28053.212      28053.212     -239.86452     -239.86452    
Loop time of 104.032 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.898 hours/ns, 9.612 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    | 103.5      | 103.5      | 103.5      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080413   | 0.080413   | 0.080413   |   0.0 |  0.08
Output  | 0.00016587 | 0.00016587 | 0.00016587 |   0.0 |  0.00
Modify  | 0.39109    | 0.39109    | 0.39109    |   0.0 |  0.38
Other   |            | 0.0597     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3119 ave        3119 max        3119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119122 ave      119122 max      119122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119122
Ave neighs/atom = 59.561
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.292706233812, Press = 7.05423328402613
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -10442.224     -10442.224     -10518.04      -10518.04       293.41474      293.41474      28053.212      28053.212     -239.86452     -239.86452    
     14000  -10442.926     -10442.926     -10521.328     -10521.328      303.42224      303.42224      28060.131      28060.131     -918.11994     -918.11994    
Loop time of 102.67 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.842 ns/day, 28.519 hours/ns, 9.740 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    | 102.15     | 102.15     | 102.15     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079736   | 0.079736   | 0.079736   |   0.0 |  0.08
Output  | 0.00039235 | 0.00039235 | 0.00039235 |   0.0 |  0.00
Modify  | 0.38376    | 0.38376    | 0.38376    |   0.0 |  0.37
Other   |            | 0.0587     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3125 ave        3125 max        3125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118972 ave      118972 max      118972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118972
Ave neighs/atom = 59.486
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.237332202829, Press = 0.790875243795873
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -10442.926     -10442.926     -10521.328     -10521.328      303.42224      303.42224      28060.131      28060.131     -918.11994     -918.11994    
     15000  -10447.898     -10447.898     -10522.167     -10522.167      287.429        287.429        28015.548      28015.548      1233.8823      1233.8823    
Loop time of 104.816 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.116 hours/ns, 9.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    | 104.29     | 104.29     | 104.29     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08063    | 0.08063    | 0.08063    |   0.0 |  0.08
Output  | 0.00016912 | 0.00016912 | 0.00016912 |   0.0 |  0.00
Modify  | 0.39088    | 0.39088    | 0.39088    |   0.0 |  0.37
Other   |            | 0.05908    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3096 ave        3096 max        3096 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118916 ave      118916 max      118916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118916
Ave neighs/atom = 59.458
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.193782969608, Press = 2.42691156892514
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -10447.898     -10447.898     -10522.167     -10522.167      287.429        287.429        28015.548      28015.548      1233.8823      1233.8823    
     16000  -10443.548     -10443.548     -10521.574     -10521.574      301.96844      301.96844      28059.464      28059.464     -921.69005     -921.69005    
Loop time of 103.115 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.838 ns/day, 28.643 hours/ns, 9.698 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    | 102.59     | 102.59     | 102.59     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080165   | 0.080165   | 0.080165   |   0.0 |  0.08
Output  | 0.00022557 | 0.00022557 | 0.00022557 |   0.0 |  0.00
Modify  | 0.38609    | 0.38609    | 0.38609    |   0.0 |  0.37
Other   |            | 0.05875    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3099 ave        3099 max        3099 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118920 ave      118920 max      118920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118920
Ave neighs/atom = 59.46
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.069437924067, Press = 7.63737025078359
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -10443.548     -10443.548     -10521.574     -10521.574      301.96844      301.96844      28059.464      28059.464     -921.69005     -921.69005    
     17000  -10449.148     -10449.148     -10522.378     -10522.378      283.4091       283.4091       28075.012      28075.012     -2184.3148     -2184.3148    
Loop time of 102.352 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.844 ns/day, 28.431 hours/ns, 9.770 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    | 101.83     | 101.83     | 101.83     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080415   | 0.080415   | 0.080415   |   0.0 |  0.08
Output  | 0.00016433 | 0.00016433 | 0.00016433 |   0.0 |  0.00
Modify  | 0.38273    | 0.38273    | 0.38273    |   0.0 |  0.37
Other   |            | 0.05843    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3135 ave        3135 max        3135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118846 ave      118846 max      118846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118846
Ave neighs/atom = 59.423
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.879755685903, Press = -3.28711795475125
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -10449.148     -10449.148     -10522.378     -10522.378      283.4091       283.4091       28075.012      28075.012     -2184.3148     -2184.3148    
     18000  -10443.127     -10443.127     -10518.09      -10518.09       290.1137       290.1137       27998.11       27998.11       2482.4036      2482.4036    
Loop time of 104.732 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.092 hours/ns, 9.548 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    | 104.19     | 104.19     | 104.19     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082047   | 0.082047   | 0.082047   |   0.0 |  0.08
Output  | 0.00022933 | 0.00022933 | 0.00022933 |   0.0 |  0.00
Modify  | 0.39598    | 0.39598    | 0.39598    |   0.0 |  0.38
Other   |            | 0.05927    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3130 ave        3130 max        3130 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118724 ave      118724 max      118724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118724
Ave neighs/atom = 59.362
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.815819446353, Press = 1.08306496736944
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -10443.127     -10443.127     -10518.09      -10518.09       290.1137       290.1137       27998.11       27998.11       2482.4036      2482.4036    
     19000  -10441.134     -10441.134     -10518.589     -10518.589      299.7598       299.7598       28052.581      28052.581     -317.3544      -317.3544     
Loop time of 106.043 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.456 hours/ns, 9.430 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    | 105.5      | 105.5      | 105.5      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081943   | 0.081943   | 0.081943   |   0.0 |  0.08
Output  | 0.00016533 | 0.00016533 | 0.00016533 |   0.0 |  0.00
Modify  | 0.39952    | 0.39952    | 0.39952    |   0.0 |  0.38
Other   |            | 0.05942    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3134 ave        3134 max        3134 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119056 ave      119056 max      119056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119056
Ave neighs/atom = 59.528
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.805945641193, Press = 5.09171359036064
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -10441.134     -10441.134     -10518.589     -10518.589      299.7598       299.7598       28052.581      28052.581     -317.3544      -317.3544     
     20000  -10445.667     -10445.667     -10521.892     -10521.892      295.00007      295.00007      28060.814      28060.814     -1174.3045     -1174.3045    
Loop time of 103.559 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.766 hours/ns, 9.656 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    | 103.03     | 103.03     | 103.03     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080891   | 0.080891   | 0.080891   |   0.0 |  0.08
Output  | 0.00016496 | 0.00016496 | 0.00016496 |   0.0 |  0.00
Modify  | 0.38726    | 0.38726    | 0.38726    |   0.0 |  0.37
Other   |            | 0.05883    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3130 ave        3130 max        3130 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118990 ave      118990 max      118990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118990
Ave neighs/atom = 59.495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.899360018403, Press = 0.62823427346657
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -10445.667     -10445.667     -10521.892     -10521.892      295.00007      295.00007      28060.814      28060.814     -1174.3045     -1174.3045    
     21000  -10445.145     -10445.145     -10520.015     -10520.015      289.7563       289.7563       28024.525      28024.525      909.86857      909.86857    
Loop time of 106.018 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.450 hours/ns, 9.432 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    | 105.48     | 105.48     | 105.48     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081708   | 0.081708   | 0.081708   |   0.0 |  0.08
Output  | 0.00016364 | 0.00016364 | 0.00016364 |   0.0 |  0.00
Modify  | 0.40074    | 0.40074    | 0.40074    |   0.0 |  0.38
Other   |            | 0.05976    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3118 ave        3118 max        3118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118872 ave      118872 max      118872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118872
Ave neighs/atom = 59.436
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.935901806619, Press = 1.07127070642266
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -10445.145     -10445.145     -10520.015     -10520.015      289.7563       289.7563       28024.525      28024.525      909.86857      909.86857    
     22000  -10450.291     -10450.291     -10524.723     -10524.723      288.056        288.056        28037.81       28037.81      -266.13966     -266.13966    
Loop time of 105.298 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.249 hours/ns, 9.497 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.76     | 104.76     | 104.76     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083004   | 0.083004   | 0.083004   |   0.0 |  0.08
Output  | 0.00023059 | 0.00023059 | 0.00023059 |   0.0 |  0.00
Modify  | 0.39748    | 0.39748    | 0.39748    |   0.0 |  0.38
Other   |            | 0.05996    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3156 ave        3156 max        3156 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118998 ave      118998 max      118998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118998
Ave neighs/atom = 59.499
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.772883485205, Press = 3.15303782244309
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -10450.291     -10450.291     -10524.723     -10524.723      288.056        288.056        28037.81       28037.81      -266.13966     -266.13966    
     23000  -10444.045     -10444.045     -10519.745     -10519.745      292.96691      292.96691      28078.292      28078.292     -1913.7436     -1913.7436    
Loop time of 103.681 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.800 hours/ns, 9.645 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    | 103.15     | 103.15     | 103.15     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080463   | 0.080463   | 0.080463   |   0.0 |  0.08
Output  | 0.00016436 | 0.00016436 | 0.00016436 |   0.0 |  0.00
Modify  | 0.38776    | 0.38776    | 0.38776    |   0.0 |  0.37
Other   |            | 0.05874    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3119 ave        3119 max        3119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118850 ave      118850 max      118850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118850
Ave neighs/atom = 59.425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.782704963244, Press = -1.4236554480457
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -10444.045     -10444.045     -10519.745     -10519.745      292.96691      292.96691      28078.292      28078.292     -1913.7436     -1913.7436    
     24000  -10443.793     -10443.793     -10520.894     -10520.894      298.38975      298.38975      27987.999      27987.999      3004.2097      3004.2097    
Loop time of 104.511 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.031 hours/ns, 9.568 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    | 103.98     | 103.98     | 103.98     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081836   | 0.081836   | 0.081836   |   0.0 |  0.08
Output  | 0.00016537 | 0.00016537 | 0.00016537 |   0.0 |  0.00
Modify  | 0.39316    | 0.39316    | 0.39316    |   0.0 |  0.38
Other   |            | 0.05964    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3152 ave        3152 max        3152 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118786 ave      118786 max      118786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118786
Ave neighs/atom = 59.393
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.773278387031, Press = 0.465728896644884
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -10443.793     -10443.793     -10520.894     -10520.894      298.38975      298.38975      27987.999      27987.999      3004.2097      3004.2097    
     25000  -10450.387     -10450.387     -10524.056     -10524.056      285.10634      285.10634      28038.06       28038.06      -286.22775     -286.22775    
Loop time of 104.8 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.111 hours/ns, 9.542 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    | 104.26     | 104.26     | 104.26     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080916   | 0.080916   | 0.080916   |   0.0 |  0.08
Output  | 0.00021382 | 0.00021382 | 0.00021382 |   0.0 |  0.00
Modify  | 0.39456    | 0.39456    | 0.39456    |   0.0 |  0.38
Other   |            | 0.05999    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3130 ave        3130 max        3130 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118976 ave      118976 max      118976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118976
Ave neighs/atom = 59.488
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.746540706136, Press = 4.20077487494636
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -10450.387     -10450.387     -10524.056     -10524.056      285.10634      285.10634      28038.06       28038.06      -286.22775     -286.22775    
     26000  -10443.705     -10443.705     -10519.714     -10519.714      294.16067      294.16067      28061.108      28061.108     -945.51043     -945.51043    
Loop time of 105.191 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.220 hours/ns, 9.507 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.65     | 104.65     | 104.65     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080893   | 0.080893   | 0.080893   |   0.0 |  0.08
Output  | 0.00016739 | 0.00016739 | 0.00016739 |   0.0 |  0.00
Modify  | 0.39664    | 0.39664    | 0.39664    |   0.0 |  0.38
Other   |            | 0.05956    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3112 ave        3112 max        3112 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118758 ave      118758 max      118758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118758
Ave neighs/atom = 59.379
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.669962185209, Press = 0.604824202878901
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -10443.705     -10443.705     -10519.714     -10519.714      294.16067      294.16067      28061.108      28061.108     -945.51043     -945.51043    
     27000  -10447.767     -10447.767     -10522         -10522          287.28866      287.28866      28018.242      28018.242      1084.6158      1084.6158    
Loop time of 105.019 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.172 hours/ns, 9.522 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    | 104.48     | 104.48     | 104.48     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082197   | 0.082197   | 0.082197   |   0.0 |  0.08
Output  | 0.00016311 | 0.00016311 | 0.00016311 |   0.0 |  0.00
Modify  | 0.39684    | 0.39684    | 0.39684    |   0.0 |  0.38
Other   |            | 0.05943    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3141 ave        3141 max        3141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118880 ave      118880 max      118880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118880
Ave neighs/atom = 59.44
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.62573243025, Press = 1.13428519945196
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -10447.767     -10447.767     -10522         -10522          287.28866      287.28866      28018.242      28018.242      1084.6158      1084.6158    
     28000  -10444.92      -10444.92      -10521.446     -10521.446      296.16173      296.16173      28054.108      28054.108     -722.90013     -722.90013    
Loop time of 105.8 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.389 hours/ns, 9.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    | 105.26     | 105.26     | 105.26     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08299    | 0.08299    | 0.08299    |   0.0 |  0.08
Output  | 0.00016352 | 0.00016352 | 0.00016352 |   0.0 |  0.00
Modify  | 0.3995     | 0.3995     | 0.3995     |   0.0 |  0.38
Other   |            | 0.05972    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3130 ave        3130 max        3130 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118936 ave      118936 max      118936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118936
Ave neighs/atom = 59.468
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.699557683177, Press = 1.50526618547581
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -10444.92      -10444.92      -10521.446     -10521.446      296.16173      296.16173      28054.108      28054.108     -722.90013     -722.90013    
     29000  -10445.454     -10445.454     -10521.472     -10521.472      294.1951       294.1951       28049.707      28049.707     -434.89831     -434.89831    
Loop time of 104.076 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.910 hours/ns, 9.608 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    | 103.55     | 103.55     | 103.55     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08101    | 0.08101    | 0.08101    |   0.0 |  0.08
Output  | 0.00016295 | 0.00016295 | 0.00016295 |   0.0 |  0.00
Modify  | 0.39026    | 0.39026    | 0.39026    |   0.0 |  0.37
Other   |            | 0.05956    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3138 ave        3138 max        3138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118894 ave      118894 max      118894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118894
Ave neighs/atom = 59.447
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.770844470271, Press = -0.432899010884478
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -10445.454     -10445.454     -10521.472     -10521.472      294.1951       294.1951       28049.707      28049.707     -434.89831     -434.89831    
     30000  -10444.146     -10444.146     -10520.301     -10520.301      294.72721      294.72721      28002.213      28002.213      2180.689       2180.689     
Loop time of 103.446 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.835 ns/day, 28.735 hours/ns, 9.667 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.92     | 102.92     | 102.92     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080781   | 0.080781   | 0.080781   |   0.0 |  0.08
Output  | 0.00024881 | 0.00024881 | 0.00024881 |   0.0 |  0.00
Modify  | 0.38715    | 0.38715    | 0.38715    |   0.0 |  0.37
Other   |            | 0.05919    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3138 ave        3138 max        3138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118886 ave      118886 max      118886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118886
Ave neighs/atom = 59.443
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.880975474307, Press = 1.46361473807885
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -10444.146     -10444.146     -10520.301     -10520.301      294.72721      294.72721      28002.213      28002.213      2180.689       2180.689     
     31000  -10446.534     -10446.534     -10522.203     -10522.203      292.84908      292.84908      28079.101      28079.101     -2157.7071     -2157.7071    
Loop time of 105.021 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.173 hours/ns, 9.522 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    | 104.49     | 104.49     | 104.49     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081849   | 0.081849   | 0.081849   |   0.0 |  0.08
Output  | 0.00024908 | 0.00024908 | 0.00024908 |   0.0 |  0.00
Modify  | 0.39327    | 0.39327    | 0.39327    |   0.0 |  0.37
Other   |            | 0.0595     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3157 ave        3157 max        3157 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119034 ave      119034 max      119034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119034
Ave neighs/atom = 59.517
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.95199466611, Press = 2.73502993783522
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -10446.534     -10446.534     -10522.203     -10522.203      292.84908      292.84908      28079.101      28079.101     -2157.7071     -2157.7071    
     32000  -10443.11      -10443.11      -10518.544     -10518.544      291.9373       291.9373       28056.76       28056.76      -669.25336     -669.25336    
Loop time of 104.447 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.013 hours/ns, 9.574 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    | 103.91     | 103.91     | 103.91     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081074   | 0.081074   | 0.081074   |   0.0 |  0.08
Output  | 0.00016346 | 0.00016346 | 0.00016346 |   0.0 |  0.00
Modify  | 0.39192    | 0.39192    | 0.39192    |   0.0 |  0.38
Other   |            | 0.05886    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3110 ave        3110 max        3110 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118752 ave      118752 max      118752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118752
Ave neighs/atom = 59.376
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.981638283389, Press = -0.24426882000332
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -10443.11      -10443.11      -10518.544     -10518.544      291.9373       291.9373       28056.76       28056.76      -669.25336     -669.25336    
     33000  -10447.762     -10447.762     -10522.449     -10522.449      289.04498      289.04498      28024.611      28024.611      670.322        670.322      
Loop time of 103.719 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.811 hours/ns, 9.641 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    | 103.19     | 103.19     | 103.19     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079589   | 0.079589   | 0.079589   |   0.0 |  0.08
Output  | 0.00016479 | 0.00016479 | 0.00016479 |   0.0 |  0.00
Modify  | 0.38664    | 0.38664    | 0.38664    |   0.0 |  0.37
Other   |            | 0.05905    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3103 ave        3103 max        3103 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118862 ave      118862 max      118862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118862
Ave neighs/atom = 59.431
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.966495862279, Press = 1.11388302642968
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -10447.762     -10447.762     -10522.449     -10522.449      289.04498      289.04498      28024.611      28024.611      670.322        670.322      
     34000  -10442.8       -10442.8       -10518.996     -10518.996      294.88506      294.88506      28055.468      28055.468     -670.04016     -670.04016    
Loop time of 103.827 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.841 hours/ns, 9.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    | 103.3      | 103.3      | 103.3      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081022   | 0.081022   | 0.081022   |   0.0 |  0.08
Output  | 0.00020917 | 0.00020917 | 0.00020917 |   0.0 |  0.00
Modify  | 0.38975    | 0.38975    | 0.38975    |   0.0 |  0.38
Other   |            | 0.05941    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3127 ave        3127 max        3127 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118924 ave      118924 max      118924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118924
Ave neighs/atom = 59.462
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.902980435416, Press = 1.28141945036689
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -10442.8       -10442.8       -10518.996     -10518.996      294.88506      294.88506      28055.468      28055.468     -670.04016     -670.04016    
     35000  -10445.381     -10445.381     -10521.974     -10521.974      296.42356      296.42356      28058.86       28058.86      -1031.7515     -1031.7515    
Loop time of 104.709 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.086 hours/ns, 9.550 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.18     | 104.18     | 104.18     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081168   | 0.081168   | 0.081168   |   0.0 |  0.08
Output  | 0.00016694 | 0.00016694 | 0.00016694 |   0.0 |  0.00
Modify  | 0.39247    | 0.39247    | 0.39247    |   0.0 |  0.37
Other   |            | 0.05951    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3112 ave        3112 max        3112 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118962 ave      118962 max      118962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118962
Ave neighs/atom = 59.481
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.893061099163, Press = -0.386224197667781
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -10445.381     -10445.381     -10521.974     -10521.974      296.42356      296.42356      28058.86       28058.86      -1031.7515     -1031.7515    
     36000  -10442.079     -10442.079     -10518.923     -10518.923      297.39386      297.39386      27984.978      27984.978      3494.5107      3494.5107    
Loop time of 104.997 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.166 hours/ns, 9.524 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    | 104.46     | 104.46     | 104.46     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081505   | 0.081505   | 0.081505   |   0.0 |  0.08
Output  | 0.0001644  | 0.0001644  | 0.0001644  |   0.0 |  0.00
Modify  | 0.39378    | 0.39378    | 0.39378    |   0.0 |  0.38
Other   |            | 0.0601     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3120 ave        3120 max        3120 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118888 ave      118888 max      118888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118888
Ave neighs/atom = 59.444
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.902760791847, Press = 0.600742922228387
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -10442.079     -10442.079     -10518.923     -10518.923      297.39386      297.39386      27984.978      27984.978      3494.5107      3494.5107    
     37000  -10445.072     -10445.072     -10520.39      -10520.39       291.48899      291.48899      28066.767      28066.767     -1192.3534     -1192.3534    
Loop time of 104.5 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.028 hours/ns, 9.569 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    | 103.96     | 103.96     | 103.96     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082126   | 0.082126   | 0.082126   |   0.0 |  0.08
Output  | 0.00016455 | 0.00016455 | 0.00016455 |   0.0 |  0.00
Modify  | 0.39602    | 0.39602    | 0.39602    |   0.0 |  0.38
Other   |            | 0.05975    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3136 ave        3136 max        3136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119006 ave      119006 max      119006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119006
Ave neighs/atom = 59.503
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.865044081927, Press = 3.05883531152268
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -10445.072     -10445.072     -10520.39      -10520.39       291.48899      291.48899      28066.767      28066.767     -1192.3534     -1192.3534    
     38000  -10446.251     -10446.251     -10520.728     -10520.728      288.23319      288.23319      28069.101      28069.101     -1363.0693     -1363.0693    
Loop time of 103.986 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.885 hours/ns, 9.617 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    | 103.46     | 103.46     | 103.46     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081374   | 0.081374   | 0.081374   |   0.0 |  0.08
Output  | 0.00016322 | 0.00016322 | 0.00016322 |   0.0 |  0.00
Modify  | 0.39012    | 0.39012    | 0.39012    |   0.0 |  0.38
Other   |            | 0.05924    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3141 ave        3141 max        3141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118756 ave      118756 max      118756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118756
Ave neighs/atom = 59.378
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.840437823759, Press = -0.9416949641911
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -10446.251     -10446.251     -10520.728     -10520.728      288.23319      288.23319      28069.101      28069.101     -1363.0693     -1363.0693    
     39000  -10446.084     -10446.084     -10520.566     -10520.566      288.25053      288.25053      28001.33       28001.33       2232.8654      2232.8654    
Loop time of 105.736 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.371 hours/ns, 9.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    | 105.2      | 105.2      | 105.2      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081167   | 0.081167   | 0.081167   |   0.0 |  0.08
Output  | 0.00022589 | 0.00022589 | 0.00022589 |   0.0 |  0.00
Modify  | 0.39414    | 0.39414    | 0.39414    |   0.0 |  0.37
Other   |            | 0.05888    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3103 ave        3103 max        3103 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118904 ave      118904 max      118904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118904
Ave neighs/atom = 59.452
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.751456551654, Press = 0.822480146032102
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -10446.084     -10446.084     -10520.566     -10520.566      288.25053      288.25053      28001.33       28001.33       2232.8654      2232.8654    
     40000  -10445.148     -10445.148     -10520.677     -10520.677      292.30577      292.30577      28060.13       28060.13      -933.46583     -933.46583    
Loop time of 105.209 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.225 hours/ns, 9.505 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    | 104.67     | 104.67     | 104.67     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082592   | 0.082592   | 0.082592   |   0.0 |  0.08
Output  | 0.00024878 | 0.00024878 | 0.00024878 |   0.0 |  0.00
Modify  | 0.39322    | 0.39322    | 0.39322    |   0.0 |  0.37
Other   |            | 0.0605     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3160 ave        3160 max        3160 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118998 ave      118998 max      118998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118998
Ave neighs/atom = 59.499
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.747518032191, Press = 1.97208682142346
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -10445.148     -10445.148     -10520.677     -10520.677      292.30577      292.30577      28060.13       28060.13      -933.46583     -933.46583    
     41000  -10442.383     -10442.383     -10520.835     -10520.835      303.61568      303.61568      28064.291      28064.291     -1072.8532     -1072.8532    
Loop time of 103.169 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.837 ns/day, 28.658 hours/ns, 9.693 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    | 102.64     | 102.64     | 102.64     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080199   | 0.080199   | 0.080199   |   0.0 |  0.08
Output  | 0.00022456 | 0.00022456 | 0.00022456 |   0.0 |  0.00
Modify  | 0.38606    | 0.38606    | 0.38606    |   0.0 |  0.37
Other   |            | 0.05899    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3114 ave        3114 max        3114 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118810 ave      118810 max      118810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118810
Ave neighs/atom = 59.405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.707416998198, Press = -0.46194572824139
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -10442.383     -10442.383     -10520.835     -10520.835      303.61568      303.61568      28064.291      28064.291     -1072.8532     -1072.8532    
     42000  -10445.181     -10445.181     -10521.487     -10521.487      295.31327      295.31327      28027.011      28027.011      692.29556      692.29556    
Loop time of 104.042 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.901 hours/ns, 9.612 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    | 103.51     | 103.51     | 103.51     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080679   | 0.080679   | 0.080679   |   0.0 |  0.08
Output  | 0.00016538 | 0.00016538 | 0.00016538 |   0.0 |  0.00
Modify  | 0.39003    | 0.39003    | 0.39003    |   0.0 |  0.37
Other   |            | 0.05896    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3111 ave        3111 max        3111 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118800 ave      118800 max      118800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118800
Ave neighs/atom = 59.4
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.741123302882, Press = 0.534772101395779
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -10445.181     -10445.181     -10521.487     -10521.487      295.31327      295.31327      28027.011      28027.011      692.29556      692.29556    
     43000  -10443.795     -10443.795     -10519.763     -10519.763      294.00409      294.00409      28046.097      28046.097     -71.324817     -71.324817    
Loop time of 104.046 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.902 hours/ns, 9.611 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    | 103.52     | 103.52     | 103.52     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080252   | 0.080252   | 0.080252   |   0.0 |  0.08
Output  | 0.00016636 | 0.00016636 | 0.00016636 |   0.0 |  0.00
Modify  | 0.38933    | 0.38933    | 0.38933    |   0.0 |  0.37
Other   |            | 0.05881    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3101 ave        3101 max        3101 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118902 ave      118902 max      118902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118902
Ave neighs/atom = 59.451
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.832339920587, Press = 0.936585348670767
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -10443.795     -10443.795     -10519.763     -10519.763      294.00409      294.00409      28046.097      28046.097     -71.324817     -71.324817    
     44000  -10444.509     -10444.509     -10519.667     -10519.667      290.86976      290.86976      28054.505      28054.505     -517.58865     -517.58865    
Loop time of 104.584 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.051 hours/ns, 9.562 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    | 104.05     | 104.05     | 104.05     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081666   | 0.081666   | 0.081666   |   0.0 |  0.08
Output  | 0.00016427 | 0.00016427 | 0.00016427 |   0.0 |  0.00
Modify  | 0.39138    | 0.39138    | 0.39138    |   0.0 |  0.37
Other   |            | 0.05924    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3136 ave        3136 max        3136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118946 ave      118946 max      118946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118946
Ave neighs/atom = 59.473
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.844299066972, Press = 0.367264152232602
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -10444.509     -10444.509     -10519.667     -10519.667      290.86976      290.86976      28054.505      28054.505     -517.58865     -517.58865    
     45000  -10447.287     -10447.287     -10522.07      -10522.07       289.41778      289.41778      28006.258      28006.258      1912.2492      1912.2492    
Loop time of 105.037 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.177 hours/ns, 9.520 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    | 104.5      | 104.5      | 104.5      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081165   | 0.081165   | 0.081165   |   0.0 |  0.08
Output  | 0.00019728 | 0.00019728 | 0.00019728 |   0.0 |  0.00
Modify  | 0.39586    | 0.39586    | 0.39586    |   0.0 |  0.38
Other   |            | 0.05993    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3112 ave        3112 max        3112 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118928 ave      118928 max      118928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118928
Ave neighs/atom = 59.464
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.898977834892, Press = 0.0860019089067132
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -10447.287     -10447.287     -10522.07      -10522.07       289.41778      289.41778      28006.258      28006.258      1912.2492      1912.2492    
     46000  -10443.941     -10443.941     -10521.035     -10521.035      298.35888      298.35888      28041.259      28041.259      114.35498      114.35498    
Loop time of 102.211 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.845 ns/day, 28.392 hours/ns, 9.784 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    | 101.69     | 101.69     | 101.69     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079816   | 0.079816   | 0.079816   |   0.0 |  0.08
Output  | 0.00016544 | 0.00016544 | 0.00016544 |   0.0 |  0.00
Modify  | 0.38253    | 0.38253    | 0.38253    |   0.0 |  0.37
Other   |            | 0.05922    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3109 ave        3109 max        3109 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118982 ave      118982 max      118982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118982
Ave neighs/atom = 59.491
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.886158500556, Press = 2.66818481104285
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -10443.941     -10443.941     -10521.035     -10521.035      298.35888      298.35888      28041.259      28041.259      114.35498      114.35498    
     47000  -10448.923     -10448.923     -10523.112     -10523.112      287.1166       287.1166       28072.93       28072.93      -2100.4972     -2100.4972    
Loop time of 106.153 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.487 hours/ns, 9.420 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    | 105.6      | 105.6      | 105.6      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083282   | 0.083282   | 0.083282   |   0.0 |  0.08
Output  | 0.00020776 | 0.00020776 | 0.00020776 |   0.0 |  0.00
Modify  | 0.4048     | 0.4048     | 0.4048     |   0.0 |  0.38
Other   |            | 0.06048    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3114 ave        3114 max        3114 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118940 ave      118940 max      118940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118940
Ave neighs/atom = 59.47
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.853047992963, Press = -0.189376633628421
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -10448.923     -10448.923     -10523.112     -10523.112      287.1166       287.1166       28072.93       28072.93      -2100.4972     -2100.4972    
     48000  -10445.152     -10445.152     -10522.895     -10522.895      300.87359      300.87359      28018.014      28018.014      1133.5351      1133.5351    
Loop time of 103.168 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.837 ns/day, 28.658 hours/ns, 9.693 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    | 102.64     | 102.64     | 102.64     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080773   | 0.080773   | 0.080773   |   0.0 |  0.08
Output  | 0.00020703 | 0.00020703 | 0.00020703 |   0.0 |  0.00
Modify  | 0.38569    | 0.38569    | 0.38569    |   0.0 |  0.37
Other   |            | 0.05932    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3138 ave        3138 max        3138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118820 ave      118820 max      118820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118820
Ave neighs/atom = 59.41
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.774085340654, Press = 0.245376384502218
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -10445.152     -10445.152     -10522.895     -10522.895      300.87359      300.87359      28018.014      28018.014      1133.5351      1133.5351    
     49000  -10445.334     -10445.334     -10519.852     -10519.852      288.39232      288.39232      28039.329      28039.329      150.46355      150.46355    
Loop time of 105.193 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.220 hours/ns, 9.506 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    | 104.65     | 104.65     | 104.65     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081541   | 0.081541   | 0.081541   |   0.0 |  0.08
Output  | 0.00016165 | 0.00016165 | 0.00016165 |   0.0 |  0.00
Modify  | 0.39945    | 0.39945    | 0.39945    |   0.0 |  0.38
Other   |            | 0.06002    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3128 ave        3128 max        3128 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118894 ave      118894 max      118894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118894
Ave neighs/atom = 59.447
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.769941535364, Press = 1.15753201525078
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -10445.334     -10445.334     -10519.852     -10519.852      288.39232      288.39232      28039.329      28039.329      150.46355      150.46355    
     50000  -10447.747     -10447.747     -10522.933     -10522.933      290.97837      290.97837      28053.212      28053.212     -880.1969      -880.1969     
Loop time of 104.247 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.957 hours/ns, 9.593 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    | 103.71     | 103.71     | 103.71     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081298   | 0.081298   | 0.081298   |   0.0 |  0.08
Output  | 0.00016704 | 0.00016704 | 0.00016704 |   0.0 |  0.00
Modify  | 0.39299    | 0.39299    | 0.39299    |   0.0 |  0.38
Other   |            | 0.05942    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3130 ave        3130 max        3130 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118846 ave      118846 max      118846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118846
Ave neighs/atom = 59.423
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.708269937929, Press = 0.32262306977616
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -10447.747     -10447.747     -10522.933     -10522.933      290.97837      290.97837      28053.212      28053.212     -880.1969      -880.1969     
     51000  -10443.455     -10443.455     -10519.546     -10519.546      294.48103      294.48103      28031.409      28031.409      552.97972      552.97972    
Loop time of 107.531 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.803 ns/day, 29.870 hours/ns, 9.300 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    | 106.98     | 106.98     | 106.98     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083517   | 0.083517   | 0.083517   |   0.0 |  0.08
Output  | 0.00016842 | 0.00016842 | 0.00016842 |   0.0 |  0.00
Modify  | 0.40516    | 0.40516    | 0.40516    |   0.0 |  0.38
Other   |            | 0.06014    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3143 ave        3143 max        3143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118828 ave      118828 max      118828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118828
Ave neighs/atom = 59.414
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.696909927619, Press = 0.0849562467748463
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -10443.455     -10443.455     -10519.546     -10519.546      294.48103      294.48103      28031.409      28031.409      552.97972      552.97972    
     52000  -10448.004     -10448.004     -10522.868     -10522.868      289.72863      289.72863      28014.852      28014.852      1143.8747      1143.8747    
Loop time of 103.903 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.862 hours/ns, 9.624 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    | 103.37     | 103.37     | 103.37     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081192   | 0.081192   | 0.081192   |   0.0 |  0.08
Output  | 0.00038747 | 0.00038747 | 0.00038747 |   0.0 |  0.00
Modify  | 0.38838    | 0.38838    | 0.38838    |   0.0 |  0.37
Other   |            | 0.05959    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3140 ave        3140 max        3140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118982 ave      118982 max      118982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118982
Ave neighs/atom = 59.491
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.664516793317, Press = 1.39604123695255
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -10448.004     -10448.004     -10522.868     -10522.868      289.72863      289.72863      28014.852      28014.852      1143.8747      1143.8747    
     53000  -10443.959     -10443.959     -10521.642     -10521.642      300.6436       300.6436       28098.2        28098.2       -3072.0174     -3072.0174    
Loop time of 103.088 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.838 ns/day, 28.636 hours/ns, 9.700 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    | 102.56     | 102.56     | 102.56     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080381   | 0.080381   | 0.080381   |   0.0 |  0.08
Output  | 0.00016291 | 0.00016291 | 0.00016291 |   0.0 |  0.00
Modify  | 0.38495    | 0.38495    | 0.38495    |   0.0 |  0.37
Other   |            | 0.05892    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3132 ave        3132 max        3132 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118952 ave      118952 max      118952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118952
Ave neighs/atom = 59.476
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.647923517118, Press = 0.630985822753908
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -10443.959     -10443.959     -10521.642     -10521.642      300.6436       300.6436       28098.2        28098.2       -3072.0174     -3072.0174    
     54000  -10446.843     -10446.843     -10522.448     -10522.448      292.59796      292.59796      28027.83       28027.83       582.33631      582.33631    
Loop time of 102.352 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.844 ns/day, 28.431 hours/ns, 9.770 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    | 101.83     | 101.83     | 101.83     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081309   | 0.081309   | 0.081309   |   0.0 |  0.08
Output  | 0.00016534 | 0.00016534 | 0.00016534 |   0.0 |  0.00
Modify  | 0.38474    | 0.38474    | 0.38474    |   0.0 |  0.38
Other   |            | 0.05896    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3134 ave        3134 max        3134 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118658 ave      118658 max      118658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118658
Ave neighs/atom = 59.329
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.666247637826, Press = -0.725177009232672
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -10446.843     -10446.843     -10522.448     -10522.448      292.59796      292.59796      28027.83       28027.83       582.33631      582.33631    
     55000  -10442.178     -10442.178     -10519.569     -10519.569      299.51067      299.51067      28025.649      28025.649      1093.9052      1093.9052    
Loop time of 101.611 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.850 ns/day, 28.225 hours/ns, 9.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    | 101.09     | 101.09     | 101.09     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080106   | 0.080106   | 0.080106   |   0.0 |  0.08
Output  | 0.00019533 | 0.00019533 | 0.00019533 |   0.0 |  0.00
Modify  | 0.3791     | 0.3791     | 0.3791     |   0.0 |  0.37
Other   |            | 0.05853    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3142 ave        3142 max        3142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118834 ave      118834 max      118834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118834
Ave neighs/atom = 59.417
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.668299025707, Press = 0.911384456601495
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -10442.178     -10442.178     -10519.569     -10519.569      299.51067      299.51067      28025.649      28025.649      1093.9052      1093.9052    
     56000  -10446.122     -10446.122     -10521.691     -10521.691      292.45781      292.45781      28048.349      28048.349     -389.27421     -389.27421    
Loop time of 103.289 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.691 hours/ns, 9.682 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    | 102.76     | 102.76     | 102.76     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080771   | 0.080771   | 0.080771   |   0.0 |  0.08
Output  | 0.00016555 | 0.00016555 | 0.00016555 |   0.0 |  0.00
Modify  | 0.38656    | 0.38656    | 0.38656    |   0.0 |  0.37
Other   |            | 0.0589     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3136 ave        3136 max        3136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118942 ave      118942 max      118942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118942
Ave neighs/atom = 59.471
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.664165262693, Press = 0.644920990582452
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -10446.122     -10446.122     -10521.691     -10521.691      292.45781      292.45781      28048.349      28048.349     -389.27421     -389.27421    
     57000  -10442.541     -10442.541     -10519.811     -10519.811      299.04312      299.04312      28048.541      28048.541     -307.12681     -307.12681    
Loop time of 103.392 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.720 hours/ns, 9.672 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    | 102.87     | 102.87     | 102.87     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080603   | 0.080603   | 0.080603   |   0.0 |  0.08
Output  | 0.00016447 | 0.00016447 | 0.00016447 |   0.0 |  0.00
Modify  | 0.38721    | 0.38721    | 0.38721    |   0.0 |  0.37
Other   |            | 0.05892    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3112 ave        3112 max        3112 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118824 ave      118824 max      118824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118824
Ave neighs/atom = 59.412
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.696393755837, Press = 0.0045028179045834
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -10442.541     -10442.541     -10519.811     -10519.811      299.04312      299.04312      28048.541      28048.541     -307.12681     -307.12681    
     58000  -10447.028     -10447.028     -10523.767     -10523.767      296.98689      296.98689      28019.691      28019.691      842.21597      842.21597    
Loop time of 101.889 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.848 ns/day, 28.302 hours/ns, 9.815 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    | 101.37     | 101.37     | 101.37     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080994   | 0.080994   | 0.080994   |   0.0 |  0.08
Output  | 0.00016481 | 0.00016481 | 0.00016481 |   0.0 |  0.00
Modify  | 0.37977    | 0.37977    | 0.37977    |   0.0 |  0.37
Other   |            | 0.0584     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3145 ave        3145 max        3145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118850 ave      118850 max      118850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118850
Ave neighs/atom = 59.425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.712419947631, Press = 0.603397689361633
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -10447.028     -10447.028     -10523.767     -10523.767      296.98689      296.98689      28019.691      28019.691      842.21597      842.21597    
     59000  -10442.834     -10442.834     -10521.371     -10521.371      303.94646      303.94646      28064.102      28064.102     -1220.8249     -1220.8249    
Loop time of 102.556 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.842 ns/day, 28.488 hours/ns, 9.751 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    | 102.03     | 102.03     | 102.03     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080879   | 0.080879   | 0.080879   |   0.0 |  0.08
Output  | 0.00019448 | 0.00019448 | 0.00019448 |   0.0 |  0.00
Modify  | 0.38448    | 0.38448    | 0.38448    |   0.0 |  0.37
Other   |            | 0.059      |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3145 ave        3145 max        3145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118956 ave      118956 max      118956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118956
Ave neighs/atom = 59.478
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.688159463426, Press = 0.58381678920459
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -10442.834     -10442.834     -10521.371     -10521.371      303.94646      303.94646      28064.102      28064.102     -1220.8249     -1220.8249    
     60000  -10446.371     -10446.371     -10523.21      -10523.21       297.37772      297.37772      28043.47       28043.47      -355.77251     -355.77251    
Loop time of 102.276 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.845 ns/day, 28.410 hours/ns, 9.777 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    | 101.75     | 101.75     | 101.75     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080083   | 0.080083   | 0.080083   |   0.0 |  0.08
Output  | 0.00025214 | 0.00025214 | 0.00025214 |   0.0 |  0.00
Modify  | 0.38266    | 0.38266    | 0.38266    |   0.0 |  0.37
Other   |            | 0.05862    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3129 ave        3129 max        3129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118870 ave      118870 max      118870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118870
Ave neighs/atom = 59.435
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.673443276457, Press = -0.399452757492457
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -10446.371     -10446.371     -10523.21      -10523.21       297.37772      297.37772      28043.47       28043.47      -355.77251     -355.77251    
     61000  -10445.357     -10445.357     -10520.441     -10520.441      290.58009      290.58009      28014.883      28014.883      1387.0607      1387.0607    
Loop time of 103.866 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.852 hours/ns, 9.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    | 103.34     | 103.34     | 103.34     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081098   | 0.081098   | 0.081098   |   0.0 |  0.08
Output  | 0.00016425 | 0.00016425 | 0.00016425 |   0.0 |  0.00
Modify  | 0.39011    | 0.39011    | 0.39011    |   0.0 |  0.38
Other   |            | 0.05935    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3121 ave        3121 max        3121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118892 ave      118892 max      118892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118892
Ave neighs/atom = 59.446
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.638788489039, Press = 0.856732851152015
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -10445.357     -10445.357     -10520.441     -10520.441      290.58009      290.58009      28014.883      28014.883      1387.0607      1387.0607    
     62000  -10446.35      -10446.35      -10522.23      -10522.23       293.66465      293.66465      28071.563      28071.563     -1996.4575     -1996.4575    
Loop time of 103.005 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.613 hours/ns, 9.708 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.48     | 102.48     | 102.48     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081418   | 0.081418   | 0.081418   |   0.0 |  0.08
Output  | 0.0001641  | 0.0001641  | 0.0001641  |   0.0 |  0.00
Modify  | 0.38906    | 0.38906    | 0.38906    |   0.0 |  0.38
Other   |            | 0.05908    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3140 ave        3140 max        3140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119032 ave      119032 max      119032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119032
Ave neighs/atom = 59.516
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.652643425545, Press = 0.491435548893352
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -10446.35      -10446.35      -10522.23      -10522.23       293.66465      293.66465      28071.563      28071.563     -1996.4575     -1996.4575    
     63000  -10445.381     -10445.381     -10521.14      -10521.14       293.19393      293.19393      28032.008      28032.008      330.93401      330.93401    
Loop time of 102.378 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.844 ns/day, 28.438 hours/ns, 9.768 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    | 101.86     | 101.86     | 101.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079838   | 0.079838   | 0.079838   |   0.0 |  0.08
Output  | 0.0001657  | 0.0001657  | 0.0001657  |   0.0 |  0.00
Modify  | 0.38193    | 0.38193    | 0.38193    |   0.0 |  0.37
Other   |            | 0.0586     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3119 ave        3119 max        3119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118876 ave      118876 max      118876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118876
Ave neighs/atom = 59.438
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.680781630886, Press = -0.487304472772459
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -10445.381     -10445.381     -10521.14      -10521.14       293.19393      293.19393      28032.008      28032.008      330.93401      330.93401    
     64000  -10446.812     -10446.812     -10520.519     -10520.519      285.25305      285.25305      28012.569      28012.569      1316.2485      1316.2485    
Loop time of 104.078 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.911 hours/ns, 9.608 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    | 103.55     | 103.55     | 103.55     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081566   | 0.081566   | 0.081566   |   0.0 |  0.08
Output  | 0.00020036 | 0.00020036 | 0.00020036 |   0.0 |  0.00
Modify  | 0.39017    | 0.39017    | 0.39017    |   0.0 |  0.37
Other   |            | 0.0593     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3127 ave        3127 max        3127 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118894 ave      118894 max      118894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118894
Ave neighs/atom = 59.447
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.705745920365, Press = 1.01765104207466
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -10446.812     -10446.812     -10520.519     -10520.519      285.25305      285.25305      28012.569      28012.569      1316.2485      1316.2485    
     65000  -10443.776     -10443.776     -10519.717     -10519.717      293.89987      293.89987      28107.285      28107.285     -3628.2901     -3628.2901    
Loop time of 103.614 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.782 hours/ns, 9.651 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    | 103.08     | 103.08     | 103.08     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081306   | 0.081306   | 0.081306   |   0.0 |  0.08
Output  | 0.00016552 | 0.00016552 | 0.00016552 |   0.0 |  0.00
Modify  | 0.38885    | 0.38885    | 0.38885    |   0.0 |  0.38
Other   |            | 0.05908    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3138 ave        3138 max        3138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119042 ave      119042 max      119042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119042
Ave neighs/atom = 59.521
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.695394706945, Press = 0.0666176266701809
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -10443.776     -10443.776     -10519.717     -10519.717      293.89987      293.89987      28107.285      28107.285     -3628.2901     -3628.2901    
     66000  -10443.574     -10443.574     -10517.986     -10517.986      287.98104      287.98104      27995.03       27995.03       2615.6475      2615.6475    
Loop time of 103.858 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.850 hours/ns, 9.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    | 103.33     | 103.33     | 103.33     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081139   | 0.081139   | 0.081139   |   0.0 |  0.08
Output  | 0.00020829 | 0.00020829 | 0.00020829 |   0.0 |  0.00
Modify  | 0.38909    | 0.38909    | 0.38909    |   0.0 |  0.37
Other   |            | 0.05914    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3124 ave        3124 max        3124 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118802 ave      118802 max      118802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118802
Ave neighs/atom = 59.401
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.666495176464, Press = -1.30446578523077
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -10443.574     -10443.574     -10517.986     -10517.986      287.98104      287.98104      27995.03       27995.03       2615.6475      2615.6475    
     67000  -10446.983     -10446.983     -10521.394     -10521.394      287.97615      287.97615      28020.563      28020.563      896.7025       896.7025     
Loop time of 101.635 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.850 ns/day, 28.232 hours/ns, 9.839 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    | 101.12     | 101.12     | 101.12     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079523   | 0.079523   | 0.079523   |   0.0 |  0.08
Output  | 0.00025878 | 0.00025878 | 0.00025878 |   0.0 |  0.00
Modify  | 0.38114    | 0.38114    | 0.38114    |   0.0 |  0.38
Other   |            | 0.05868    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3137 ave        3137 max        3137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119120 ave      119120 max      119120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119120
Ave neighs/atom = 59.56
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.670522150425, Press = 1.25429047048063
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -10446.983     -10446.983     -10521.394     -10521.394      287.97615      287.97615      28020.563      28020.563      896.7025       896.7025     
     68000  -10443.788     -10443.788     -10517.953     -10517.953      287.028        287.028        28069.092      28069.092     -1331.7245     -1331.7245    
Loop time of 102.087 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.846 ns/day, 28.357 hours/ns, 9.796 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    | 101.56     | 101.56     | 101.56     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080059   | 0.080059   | 0.080059   |   0.0 |  0.08
Output  | 0.00016705 | 0.00016705 | 0.00016705 |   0.0 |  0.00
Modify  | 0.38307    | 0.38307    | 0.38307    |   0.0 |  0.38
Other   |            | 0.05886    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3113 ave        3113 max        3113 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118910 ave      118910 max      118910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118910
Ave neighs/atom = 59.455
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.660599335618, Press = 0.195261277134064
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -10443.788     -10443.788     -10517.953     -10517.953      287.028        287.028        28069.092      28069.092     -1331.7245     -1331.7245    
     69000  -10445.327     -10445.327     -10521.209     -10521.209      293.67431      293.67431      28017.613      28017.613      1122.6582      1122.6582    
Loop time of 103.88 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.855 hours/ns, 9.627 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.35     | 103.35     | 103.35     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081882   | 0.081882   | 0.081882   |   0.0 |  0.08
Output  | 0.00016643 | 0.00016643 | 0.00016643 |   0.0 |  0.00
Modify  | 0.39037    | 0.39037    | 0.39037    |   0.0 |  0.38
Other   |            | 0.05976    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3160 ave        3160 max        3160 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118842 ave      118842 max      118842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118842
Ave neighs/atom = 59.421
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.65473365618, Press = 0.0356171479226975
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -10445.327     -10445.327     -10521.209     -10521.209      293.67431      293.67431      28017.613      28017.613      1122.6582      1122.6582    
     70000  -10441.035     -10441.035     -10517.367     -10517.367      295.41192      295.41192      28039.001      28039.001      404.00539      404.00539    
Loop time of 103.138 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.838 ns/day, 28.649 hours/ns, 9.696 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    | 102.61     | 102.61     | 102.61     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081196   | 0.081196   | 0.081196   |   0.0 |  0.08
Output  | 0.00016471 | 0.00016471 | 0.00016471 |   0.0 |  0.00
Modify  | 0.38683    | 0.38683    | 0.38683    |   0.0 |  0.38
Other   |            | 0.05948    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3124 ave        3124 max        3124 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118980 ave      118980 max      118980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118980
Ave neighs/atom = 59.49
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.669440996145, Press = 0.989214784051238
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -10441.035     -10441.035     -10517.367     -10517.367      295.41192      295.41192      28039.001      28039.001      404.00539      404.00539    
     71000  -10445.238     -10445.238     -10520.556     -10520.556      291.48726      291.48726      28086.94       28086.94      -2548.2729     -2548.2729    
Loop time of 102.777 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.841 ns/day, 28.549 hours/ns, 9.730 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    | 102.25     | 102.25     | 102.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080461   | 0.080461   | 0.080461   |   0.0 |  0.08
Output  | 0.00016322 | 0.00016322 | 0.00016322 |   0.0 |  0.00
Modify  | 0.38306    | 0.38306    | 0.38306    |   0.0 |  0.37
Other   |            | 0.05909    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3139 ave        3139 max        3139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118954 ave      118954 max      118954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118954
Ave neighs/atom = 59.477
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.705275782994, Press = -0.0687298616063818
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -10445.238     -10445.238     -10520.556     -10520.556      291.48726      291.48726      28086.94       28086.94      -2548.2729     -2548.2729    
     72000  -10440.791     -10440.791     -10519.54      -10519.54       304.76771      304.76771      27987.462      27987.462      3118.4366      3118.4366    
Loop time of 103.782 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.828 hours/ns, 9.636 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    | 103.25     | 103.25     | 103.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07992    | 0.07992    | 0.07992    |   0.0 |  0.08
Output  | 0.00020553 | 0.00020553 | 0.00020553 |   0.0 |  0.00
Modify  | 0.38895    | 0.38895    | 0.38895    |   0.0 |  0.37
Other   |            | 0.05863    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3118 ave        3118 max        3118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118880 ave      118880 max      118880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118880
Ave neighs/atom = 59.44
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.741819961549, Press = -0.351591151460403
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -10440.791     -10440.791     -10519.54      -10519.54       304.76771      304.76771      27987.462      27987.462      3118.4366      3118.4366    
     73000  -10445.881     -10445.881     -10522.398     -10522.398      296.12813      296.12813      28033.247      28033.247      303.59355      303.59355    
Loop time of 102.668 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.842 ns/day, 28.519 hours/ns, 9.740 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    | 102.15     | 102.15     | 102.15     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0802     | 0.0802     | 0.0802     |   0.0 |  0.08
Output  | 0.00016342 | 0.00016342 | 0.00016342 |   0.0 |  0.00
Modify  | 0.3822     | 0.3822     | 0.3822     |   0.0 |  0.37
Other   |            | 0.05882    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3140 ave        3140 max        3140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119074 ave      119074 max      119074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119074
Ave neighs/atom = 59.537
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.763579491319, Press = 1.13055383646369
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -10445.881     -10445.881     -10522.398     -10522.398      296.12813      296.12813      28033.247      28033.247      303.59355      303.59355    
     74000  -10444.56      -10444.56      -10522.528     -10522.528      301.74447      301.74447      28062.833      28062.833     -1360.0403     -1360.0403    
Loop time of 101.941 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.848 ns/day, 28.317 hours/ns, 9.810 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    | 101.42     | 101.42     | 101.42     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079721   | 0.079721   | 0.079721   |   0.0 |  0.08
Output  | 0.00016742 | 0.00016742 | 0.00016742 |   0.0 |  0.00
Modify  | 0.37815    | 0.37815    | 0.37815    |   0.0 |  0.37
Other   |            | 0.05862    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3112 ave        3112 max        3112 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118928 ave      118928 max      118928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118928
Ave neighs/atom = 59.464
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.77868585665, Press = 0.177290899666115
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -10444.56      -10444.56      -10522.528     -10522.528      301.74447      301.74447      28062.833      28062.833     -1360.0403     -1360.0403    
     75000  -10444.201     -10444.201     -10521.198     -10521.198      297.98626      297.98626      28017.578      28017.578      1367.9395      1367.9395    
Loop time of 102.891 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.840 ns/day, 28.581 hours/ns, 9.719 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    | 102.37     | 102.37     | 102.37     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079847   | 0.079847   | 0.079847   |   0.0 |  0.08
Output  | 0.00022776 | 0.00022776 | 0.00022776 |   0.0 |  0.00
Modify  | 0.38497    | 0.38497    | 0.38497    |   0.0 |  0.37
Other   |            | 0.0576     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3105 ave        3105 max        3105 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118844 ave      118844 max      118844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118844
Ave neighs/atom = 59.422
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.753728359364, Press = 0.0432446155317958
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -10444.201     -10444.201     -10521.198     -10521.198      297.98626      297.98626      28017.578      28017.578      1367.9395      1367.9395    
     76000  -10448.835     -10448.835     -10522.029     -10522.029      283.27031      283.27031      28031.672      28031.672      277.83063      277.83063    
Loop time of 102.975 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.604 hours/ns, 9.711 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    | 102.45     | 102.45     | 102.45     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081144   | 0.081144   | 0.081144   |   0.0 |  0.08
Output  | 0.0001658  | 0.0001658  | 0.0001658  |   0.0 |  0.00
Modify  | 0.38594    | 0.38594    | 0.38594    |   0.0 |  0.37
Other   |            | 0.05837    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3157 ave        3157 max        3157 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118910 ave      118910 max      118910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118910
Ave neighs/atom = 59.455
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.740253134081, Press = 1.38591561201553
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -10448.835     -10448.835     -10522.029     -10522.029      283.27031      283.27031      28031.672      28031.672      277.83063      277.83063    
     77000  -10442.689     -10442.689     -10519.21      -10519.21       296.14452      296.14452      28109.101      28109.101     -3459.0316     -3459.0316    
Loop time of 102.224 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.845 ns/day, 28.396 hours/ns, 9.782 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    | 101.7      | 101.7      | 101.7      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08001    | 0.08001    | 0.08001    |   0.0 |  0.08
Output  | 0.00016381 | 0.00016381 | 0.00016381 |   0.0 |  0.00
Modify  | 0.38314    | 0.38314    | 0.38314    |   0.0 |  0.37
Other   |            | 0.0578     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3122 ave        3122 max        3122 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118934 ave      118934 max      118934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118934
Ave neighs/atom = 59.467
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.721589110571, Press = -0.256828981439916
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -10442.689     -10442.689     -10519.21      -10519.21       296.14452      296.14452      28109.101      28109.101     -3459.0316     -3459.0316    
     78000  -10446.413     -10446.413     -10521.137     -10521.137      289.18786      289.18786      28005.607      28005.607      1943.7528      1943.7528    
Loop time of 103.034 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.620 hours/ns, 9.706 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    | 102.51     | 102.51     | 102.51     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080588   | 0.080588   | 0.080588   |   0.0 |  0.08
Output  | 0.00016667 | 0.00016667 | 0.00016667 |   0.0 |  0.00
Modify  | 0.38844    | 0.38844    | 0.38844    |   0.0 |  0.38
Other   |            | 0.05869    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3143 ave        3143 max        3143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118694 ave      118694 max      118694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118694
Ave neighs/atom = 59.347
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.712629108666, Press = 0.103482636146404
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -10446.413     -10446.413     -10521.137     -10521.137      289.18786      289.18786      28005.607      28005.607      1943.7528      1943.7528    
     79000  -10440.151     -10440.151     -10517.448     -10517.448      299.14805      299.14805      28041.967      28041.967      382.37112      382.37112    
Loop time of 102.443 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.843 ns/day, 28.456 hours/ns, 9.762 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    | 101.92     | 101.92     | 101.92     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080282   | 0.080282   | 0.080282   |   0.0 |  0.08
Output  | 0.00016382 | 0.00016382 | 0.00016382 |   0.0 |  0.00
Modify  | 0.38162    | 0.38162    | 0.38162    |   0.0 |  0.37
Other   |            | 0.05829    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3169 ave        3169 max        3169 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118988 ave      118988 max      118988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118988
Ave neighs/atom = 59.494
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.743427131405, Press = 0.821146574989941
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -10440.151     -10440.151     -10517.448     -10517.448      299.14805      299.14805      28041.967      28041.967      382.37112      382.37112    
     80000  -10444.847     -10444.847     -10520.525     -10520.525      292.88162      292.88162      28060.239      28060.239     -1096.8094     -1096.8094    
Loop time of 103.605 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.779 hours/ns, 9.652 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    | 103.07     | 103.07     | 103.07     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081413   | 0.081413   | 0.081413   |   0.0 |  0.08
Output  | 0.00016512 | 0.00016512 | 0.00016512 |   0.0 |  0.00
Modify  | 0.39096    | 0.39096    | 0.39096    |   0.0 |  0.38
Other   |            | 0.05903    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3138 ave        3138 max        3138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118926 ave      118926 max      118926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118926
Ave neighs/atom = 59.463
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.771472124256, Press = 0.312370595139522
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -10444.847     -10444.847     -10520.525     -10520.525      292.88162      292.88162      28060.239      28060.239     -1096.8094     -1096.8094    
     81000  -10443.33      -10443.33      -10518.563     -10518.563      291.15842      291.15842      28035.527      28035.527      536.96566      536.96566    
Loop time of 103.996 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.888 hours/ns, 9.616 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    | 103.47     | 103.47     | 103.47     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080149   | 0.080149   | 0.080149   |   0.0 |  0.08
Output  | 0.0001997  | 0.0001997  | 0.0001997  |   0.0 |  0.00
Modify  | 0.39081    | 0.39081    | 0.39081    |   0.0 |  0.38
Other   |            | 0.05906    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3107 ave        3107 max        3107 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118854 ave      118854 max      118854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118854
Ave neighs/atom = 59.427
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.775318350378, Press = -0.0783541251203996
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -10443.33      -10443.33      -10518.563     -10518.563      291.15842      291.15842      28035.527      28035.527      536.96566      536.96566    
     82000  -10444.735     -10444.735     -10519.831     -10519.831      290.62718      290.62718      27997.786      27997.786      2479.1898      2479.1898    
Loop time of 103.619 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.783 hours/ns, 9.651 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    | 103.09     | 103.09     | 103.09     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080278   | 0.080278   | 0.080278   |   0.0 |  0.08
Output  | 0.00016317 | 0.00016317 | 0.00016317 |   0.0 |  0.00
Modify  | 0.38767    | 0.38767    | 0.38767    |   0.0 |  0.37
Other   |            | 0.0582     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3118 ave        3118 max        3118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118966 ave      118966 max      118966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118966
Ave neighs/atom = 59.483
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.772918785971, Press = 1.25963484182388
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -10444.735     -10444.735     -10519.831     -10519.831      290.62718      290.62718      27997.786      27997.786      2479.1898      2479.1898    
     83000  -10447.992     -10447.992     -10522.68      -10522.68       289.04935      289.04935      28085.832      28085.832     -2563.0678     -2563.0678    
Loop time of 103.935 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.871 hours/ns, 9.621 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    | 103.4      | 103.4      | 103.4      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081032   | 0.081032   | 0.081032   |   0.0 |  0.08
Output  | 0.00016366 | 0.00016366 | 0.00016366 |   0.0 |  0.00
Modify  | 0.39081    | 0.39081    | 0.39081    |   0.0 |  0.38
Other   |            | 0.05892    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3108 ave        3108 max        3108 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119092 ave      119092 max      119092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119092
Ave neighs/atom = 59.546
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.764516059402, Press = 0.685235489395568
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -10447.992     -10447.992     -10522.68      -10522.68       289.04935      289.04935      28085.832      28085.832     -2563.0678     -2563.0678    
     84000  -10443.345     -10443.345     -10520.995     -10520.995      300.5147       300.5147       28039.559      28039.559      174.85451      174.85451    
Loop time of 103.143 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.838 ns/day, 28.651 hours/ns, 9.695 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    | 102.62     | 102.62     | 102.62     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080014   | 0.080014   | 0.080014   |   0.0 |  0.08
Output  | 0.00019881 | 0.00019881 | 0.00019881 |   0.0 |  0.00
Modify  | 0.38457    | 0.38457    | 0.38457    |   0.0 |  0.37
Other   |            | 0.05893    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3111 ave        3111 max        3111 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118760 ave      118760 max      118760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118760
Ave neighs/atom = 59.38
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.744595300124, Press = -0.110188416156794
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -10443.345     -10443.345     -10520.995     -10520.995      300.5147       300.5147       28039.559      28039.559      174.85451      174.85451    
     85000  -10445.886     -10445.886     -10522.682     -10522.682      297.20777      297.20777      28020.502      28020.502      1060.4231      1060.4231    
Loop time of 103.116 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.838 ns/day, 28.643 hours/ns, 9.698 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    | 102.59     | 102.59     | 102.59     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080775   | 0.080775   | 0.080775   |   0.0 |  0.08
Output  | 0.00016276 | 0.00016276 | 0.00016276 |   0.0 |  0.00
Modify  | 0.38741    | 0.38741    | 0.38741    |   0.0 |  0.38
Other   |            | 0.05817    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3139 ave        3139 max        3139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118952 ave      118952 max      118952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118952
Ave neighs/atom = 59.476
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.73243141425, Press = 0.633911524751781
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -10445.886     -10445.886     -10522.682     -10522.682      297.20777      297.20777      28020.502      28020.502      1060.4231      1060.4231    
     86000  -10441.496     -10441.496     -10518.624     -10518.624      298.49252      298.49252      28062.664      28062.664     -879.04422     -879.04422    
Loop time of 101.895 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.848 ns/day, 28.304 hours/ns, 9.814 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    | 101.37     | 101.37     | 101.37     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079691   | 0.079691   | 0.079691   |   0.0 |  0.08
Output  | 0.00019498 | 0.00019498 | 0.00019498 |   0.0 |  0.00
Modify  | 0.38386    | 0.38386    | 0.38386    |   0.0 |  0.38
Other   |            | 0.05799    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3138 ave        3138 max        3138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118884 ave      118884 max      118884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118884
Ave neighs/atom = 59.442
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.742569542737, Press = 0.344184861566123
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -10441.496     -10441.496     -10518.624     -10518.624      298.49252      298.49252      28062.664      28062.664     -879.04422     -879.04422    
     87000  -10446.186     -10446.186     -10518.74      -10518.74       280.79212      280.79212      28029.713      28029.713      732.05205      732.05205    
Loop time of 105.281 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.245 hours/ns, 9.498 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    | 104.74     | 104.74     | 104.74     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082566   | 0.082566   | 0.082566   |   0.0 |  0.08
Output  | 0.00016355 | 0.00016355 | 0.00016355 |   0.0 |  0.00
Modify  | 0.39733    | 0.39733    | 0.39733    |   0.0 |  0.38
Other   |            | 0.05875    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3139 ave        3139 max        3139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118870 ave      118870 max      118870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118870
Ave neighs/atom = 59.435
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.754989336799, Press = 0.138066369193174
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -10446.186     -10446.186     -10518.74      -10518.74       280.79212      280.79212      28029.713      28029.713      732.05205      732.05205    
     88000  -10444.378     -10444.378     -10520.059     -10520.059      292.89346      292.89346      28035.345      28035.345      417.32222      417.32222    
Loop time of 104.15 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.931 hours/ns, 9.602 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.62     | 103.62     | 103.62     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08179    | 0.08179    | 0.08179    |   0.0 |  0.08
Output  | 0.00019575 | 0.00019575 | 0.00019575 |   0.0 |  0.00
Modify  | 0.39429    | 0.39429    | 0.39429    |   0.0 |  0.38
Other   |            | 0.05888    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3162 ave        3162 max        3162 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118960 ave      118960 max      118960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118960
Ave neighs/atom = 59.48
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.729802203696, Press = 0.514209485426153
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -10444.378     -10444.378     -10520.059     -10520.059      292.89346      292.89346      28035.345      28035.345      417.32222      417.32222    
     89000  -10446.782     -10446.782     -10522.535     -10522.535      293.16952      293.16952      28060.683      28060.683     -1260.3981     -1260.3981    
Loop time of 105.599 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.333 hours/ns, 9.470 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.06     | 105.06     | 105.06     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082598   | 0.082598   | 0.082598   |   0.0 |  0.08
Output  | 0.00016481 | 0.00016481 | 0.00016481 |   0.0 |  0.00
Modify  | 0.39892    | 0.39892    | 0.39892    |   0.0 |  0.38
Other   |            | 0.05905    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3141 ave        3141 max        3141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118870 ave      118870 max      118870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118870
Ave neighs/atom = 59.435
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.739845486737, Press = 0.287671988955451
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -10446.782     -10446.782     -10522.535     -10522.535      293.16952      293.16952      28060.683      28060.683     -1260.3981     -1260.3981    
     90000  -10446.174     -10446.174     -10522.219     -10522.219      294.30445      294.30445      28015.922      28015.922      1280.8909      1280.8909    
Loop time of 103.566 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.768 hours/ns, 9.656 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    | 103.04     | 103.04     | 103.04     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080367   | 0.080367   | 0.080367   |   0.0 |  0.08
Output  | 0.0014665  | 0.0014665  | 0.0014665  |   0.0 |  0.00
Modify  | 0.38783    | 0.38783    | 0.38783    |   0.0 |  0.37
Other   |            | 0.05835    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3121 ave        3121 max        3121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118774 ave      118774 max      118774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118774
Ave neighs/atom = 59.387
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.73339523189, Press = -0.303508279146235
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     90000  -10446.174     -10446.174     -10522.219     -10522.219      294.30445      294.30445      28015.922      28015.922      1280.8909      1280.8909    
     91000  -10445.176     -10445.176     -10521.237     -10521.237      294.36355      294.36355      28011.089      28011.089      1654.741       1654.741     
Loop time of 104.563 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.045 hours/ns, 9.564 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    | 104.03     | 104.03     | 104.03     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080997   | 0.080997   | 0.080997   |   0.0 |  0.08
Output  | 0.00020855 | 0.00020855 | 0.00020855 |   0.0 |  0.00
Modify  | 0.39253    | 0.39253    | 0.39253    |   0.0 |  0.38
Other   |            | 0.0587     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3116 ave        3116 max        3116 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118894 ave      118894 max      118894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118894
Ave neighs/atom = 59.447
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.72092447792, Press = 1.28006867714908
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     91000  -10445.176     -10445.176     -10521.237     -10521.237      294.36355      294.36355      28011.089      28011.089      1654.741       1654.741     
     92000  -10443.318     -10443.318     -10519.504     -10519.504      294.84711      294.84711      28081.898      28081.898     -2048.4984     -2048.4984    
Loop time of 104.048 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.902 hours/ns, 9.611 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    | 103.52     | 103.52     | 103.52     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079941   | 0.079941   | 0.079941   |   0.0 |  0.08
Output  | 0.00016461 | 0.00016461 | 0.00016461 |   0.0 |  0.00
Modify  | 0.39195    | 0.39195    | 0.39195    |   0.0 |  0.38
Other   |            | 0.05872    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3106 ave        3106 max        3106 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118906 ave      118906 max      118906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118906
Ave neighs/atom = 59.453
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.714444928477, Press = 0.262496934562302
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     92000  -10443.318     -10443.318     -10519.504     -10519.504      294.84711      294.84711      28081.898      28081.898     -2048.4984     -2048.4984    
     93000  -10447.019     -10447.019     -10521.66      -10521.66       288.86903      288.86903      28020.812      28020.812      1051.168       1051.168     
Loop time of 102.847 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.840 ns/day, 28.569 hours/ns, 9.723 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    | 102.32     | 102.32     | 102.32     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080046   | 0.080046   | 0.080046   |   0.0 |  0.08
Output  | 0.00020848 | 0.00020848 | 0.00020848 |   0.0 |  0.00
Modify  | 0.38588    | 0.38588    | 0.38588    |   0.0 |  0.38
Other   |            | 0.05811    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3098 ave        3098 max        3098 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118810 ave      118810 max      118810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118810
Ave neighs/atom = 59.405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.710217096161, Press = -0.0342230810367775
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -10447.019     -10447.019     -10521.66      -10521.66       288.86903      288.86903      28020.812      28020.812      1051.168       1051.168     
     94000  -10444.452     -10444.452     -10520.987     -10520.987      296.19846      296.19846      28025.357      28025.357      911.16114      911.16114    
Loop time of 102.921 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.589 hours/ns, 9.716 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.4      | 102.4      | 102.4      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079898   | 0.079898   | 0.079898   |   0.0 |  0.08
Output  | 0.00016573 | 0.00016573 | 0.00016573 |   0.0 |  0.00
Modify  | 0.38286    | 0.38286    | 0.38286    |   0.0 |  0.37
Other   |            | 0.05794    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3095 ave        3095 max        3095 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118930 ave      118930 max      118930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118930
Ave neighs/atom = 59.465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.685573490007, Press = 0.761000953250493
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -10444.452     -10444.452     -10520.987     -10520.987      296.19846      296.19846      28025.357      28025.357      911.16114      911.16114    
     95000  -10447.197     -10447.197     -10522.463     -10522.463      291.28544      291.28544      28079.894      28079.894     -2222.6321     -2222.6321    
Loop time of 103.953 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.876 hours/ns, 9.620 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.42     | 103.42     | 103.42     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080685   | 0.080685   | 0.080685   |   0.0 |  0.08
Output  | 0.00020876 | 0.00020876 | 0.00020876 |   0.0 |  0.00
Modify  | 0.39071    | 0.39071    | 0.39071    |   0.0 |  0.38
Other   |            | 0.05916    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3132 ave        3132 max        3132 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118960 ave      118960 max      118960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118960
Ave neighs/atom = 59.48
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.688438542977, Press = 0.341080847998765
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -10447.197     -10447.197     -10522.463     -10522.463      291.28544      291.28544      28079.894      28079.894     -2222.6321     -2222.6321    
     96000  -10442.955     -10442.955     -10520.88      -10520.88       301.578        301.578        28030.029      28030.029      737.40493      737.40493    
Loop time of 103.469 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.835 ns/day, 28.741 hours/ns, 9.665 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.94     | 102.94     | 102.94     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080327   | 0.080327   | 0.080327   |   0.0 |  0.08
Output  | 0.00016421 | 0.00016421 | 0.00016421 |   0.0 |  0.00
Modify  | 0.38997    | 0.38997    | 0.38997    |   0.0 |  0.38
Other   |            | 0.05886    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3154 ave        3154 max        3154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118674 ave      118674 max      118674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118674
Ave neighs/atom = 59.337
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.684517159213, Press = -0.287108185069939
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -10442.955     -10442.955     -10520.88      -10520.88       301.578        301.578        28030.029      28030.029      737.40493      737.40493    
     97000  -10444.372     -10444.372     -10521.065     -10521.065      296.81187      296.81187      28016.723      28016.723      1443.7447      1443.7447    
Loop time of 102.643 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.842 ns/day, 28.512 hours/ns, 9.742 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.12     | 102.12     | 102.12     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080348   | 0.080348   | 0.080348   |   0.0 |  0.08
Output  | 0.00020267 | 0.00020267 | 0.00020267 |   0.0 |  0.00
Modify  | 0.3848     | 0.3848     | 0.3848     |   0.0 |  0.37
Other   |            | 0.05815    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3141 ave        3141 max        3141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118878 ave      118878 max      118878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118878
Ave neighs/atom = 59.439
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.700784176613, Press = 0.732592217889735
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     97000  -10444.372     -10444.372     -10521.065     -10521.065      296.81187      296.81187      28016.723      28016.723      1443.7447      1443.7447    
     98000  -10446.192     -10446.192     -10520.736     -10520.736      288.49085      288.49085      28052.996      28052.996     -625.13734     -625.13734    
Loop time of 103.088 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.838 ns/day, 28.636 hours/ns, 9.700 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    | 102.56     | 102.56     | 102.56     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080923   | 0.080923   | 0.080923   |   0.0 |  0.08
Output  | 0.00016378 | 0.00016378 | 0.00016378 |   0.0 |  0.00
Modify  | 0.38821    | 0.38821    | 0.38821    |   0.0 |  0.38
Other   |            | 0.05824    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3148 ave        3148 max        3148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118894 ave      118894 max      118894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118894
Ave neighs/atom = 59.447
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.730695300464, Press = 0.371735231654953
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -10446.192     -10446.192     -10520.736     -10520.736      288.49085      288.49085      28052.996      28052.996     -625.13734     -625.13734    
     99000  -10441.933     -10441.933     -10520.387     -10520.387      303.62442      303.62442      28046.7        28046.7       -84.245189     -84.245189    
Loop time of 105.379 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.272 hours/ns, 9.490 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    | 104.84     | 104.84     | 104.84     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083514   | 0.083514   | 0.083514   |   0.0 |  0.08
Output  | 0.0001658  | 0.0001658  | 0.0001658  |   0.0 |  0.00
Modify  | 0.3975     | 0.3975     | 0.3975     |   0.0 |  0.38
Other   |            | 0.0598     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3176 ave        3176 max        3176 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118916 ave      118916 max      118916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118916
Ave neighs/atom = 59.458
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.744926845509, Press = 0.171543918598778
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -10441.933     -10441.933     -10520.387     -10520.387      303.62442      303.62442      28046.7        28046.7       -84.245189     -84.245189    
    100000  -10445.517     -10445.517     -10522.869     -10522.869      299.36115      299.36115      28031.685      28031.685      340.58886      340.58886    
Loop time of 105.006 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.168 hours/ns, 9.523 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    | 104.47     | 104.47     | 104.47     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082029   | 0.082029   | 0.082029   |   0.0 |  0.08
Output  | 0.00016565 | 0.00016565 | 0.00016565 |   0.0 |  0.00
Modify  | 0.39619    | 0.39619    | 0.39619    |   0.0 |  0.38
Other   |            | 0.05903    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3127 ave        3127 max        3127 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118798 ave      118798 max      118798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118798
Ave neighs/atom = 59.399
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.745392505702, Press = 0.505712441582959
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    100000  -10445.517     -10445.517     -10522.869     -10522.869      299.36115      299.36115      28031.685      28031.685      340.58886      340.58886    
    101000  -10449.095     -10449.095     -10520.478     -10520.478      276.25812      276.25812      28068.691      28068.691     -1489.1014     -1489.1014    
Loop time of 103.703 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.806 hours/ns, 9.643 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    | 103.18     | 103.18     | 103.18     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080216   | 0.080216   | 0.080216   |   0.0 |  0.08
Output  | 0.00016506 | 0.00016506 | 0.00016506 |   0.0 |  0.00
Modify  | 0.38742    | 0.38742    | 0.38742    |   0.0 |  0.37
Other   |            | 0.05877    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3126 ave        3126 max        3126 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118962 ave      118962 max      118962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118962
Ave neighs/atom = 59.481
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.743254087988, Press = 0.277241768267227
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -10449.095     -10449.095     -10520.478     -10520.478      276.25812      276.25812      28068.691      28068.691     -1489.1014     -1489.1014    
    102000  -10444.481     -10444.481     -10519.704     -10519.704      291.12043      291.12043      28023.326      28023.326      1115.2908      1115.2908    
Loop time of 102.504 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.843 ns/day, 28.473 hours/ns, 9.756 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    | 101.98     | 101.98     | 101.98     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07915    | 0.07915    | 0.07915    |   0.0 |  0.08
Output  | 0.00016342 | 0.00016342 | 0.00016342 |   0.0 |  0.00
Modify  | 0.38396    | 0.38396    | 0.38396    |   0.0 |  0.37
Other   |            | 0.05808    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3096 ave        3096 max        3096 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118850 ave      118850 max      118850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118850
Ave neighs/atom = 59.425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.72435135042, Press = -0.360034841639567
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    102000  -10444.481     -10444.481     -10519.704     -10519.704      291.12043      291.12043      28023.326      28023.326      1115.2908      1115.2908    
    103000  -10449.4       -10449.4       -10522.194     -10522.194      281.72195      281.72195      28009.239      28009.239      1518.6452      1518.6452    
Loop time of 106.681 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.634 hours/ns, 9.374 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.13     | 106.13     | 106.13     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082322   | 0.082322   | 0.082322   |   0.0 |  0.08
Output  | 0.00026208 | 0.00026208 | 0.00026208 |   0.0 |  0.00
Modify  | 0.40702    | 0.40702    | 0.40702    |   0.0 |  0.38
Other   |            | 0.06003    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3100 ave        3100 max        3100 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119006 ave      119006 max      119006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119006
Ave neighs/atom = 59.503
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.714644678806, Press = 0.802999018505496
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    103000  -10449.4       -10449.4       -10522.194     -10522.194      281.72195      281.72195      28009.239      28009.239      1518.6452      1518.6452    
    104000  -10442.056     -10442.056     -10518.428     -10518.428      295.56825      295.56825      28073.89       28073.89      -1488.5266     -1488.5266    
Loop time of 103.329 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.702 hours/ns, 9.678 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    | 102.8      | 102.8      | 102.8      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080366   | 0.080366   | 0.080366   |   0.0 |  0.08
Output  | 0.00016337 | 0.00016337 | 0.00016337 |   0.0 |  0.00
Modify  | 0.38833    | 0.38833    | 0.38833    |   0.0 |  0.38
Other   |            | 0.0583     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3107 ave        3107 max        3107 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119020 ave      119020 max      119020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119020
Ave neighs/atom = 59.51
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.700578504838, Press = 0.297276899864214
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    104000  -10442.056     -10442.056     -10518.428     -10518.428      295.56825      295.56825      28073.89       28073.89      -1488.5266     -1488.5266    
    105000  -10445.155     -10445.155     -10522.97      -10522.97       301.15307      301.15307      28038.25       28038.25      -21.072922     -21.072922    
Loop time of 103.875 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.854 hours/ns, 9.627 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.35     | 103.35     | 103.35     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080651   | 0.080651   | 0.080651   |   0.0 |  0.08
Output  | 0.00016407 | 0.00016407 | 0.00016407 |   0.0 |  0.00
Modify  | 0.38986    | 0.38986    | 0.38986    |   0.0 |  0.38
Other   |            | 0.05886    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3117 ave        3117 max        3117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118882 ave      118882 max      118882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118882
Ave neighs/atom = 59.441
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.718853408416, Press = 0.0945554682654658
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    105000  -10445.155     -10445.155     -10522.97      -10522.97       301.15307      301.15307      28038.25       28038.25      -21.072922     -21.072922    
    106000  -10441.681     -10441.681     -10518.999     -10518.999      299.22933      299.22933      28042.95       28042.95       130.23042      130.23042    
Loop time of 106.169 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.491 hours/ns, 9.419 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    | 105.63     | 105.63     | 105.63     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081578   | 0.081578   | 0.081578   |   0.0 |  0.08
Output  | 0.00027081 | 0.00027081 | 0.00027081 |   0.0 |  0.00
Modify  | 0.40173    | 0.40173    | 0.40173    |   0.0 |  0.38
Other   |            | 0.06008    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3101 ave        3101 max        3101 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118860 ave      118860 max      118860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118860
Ave neighs/atom = 59.43
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.749048339783, Press = 0.255671341461687
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    106000  -10441.681     -10441.681     -10518.999     -10518.999      299.22933      299.22933      28042.95       28042.95       130.23042      130.23042    
    107000  -10445.374     -10445.374     -10519.608     -10519.608      287.29414      287.29414      28043.617      28043.617     -156.57264     -156.57264    
Loop time of 105.716 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.366 hours/ns, 9.459 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    | 105.17     | 105.17     | 105.17     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082017   | 0.082017   | 0.082017   |   0.0 |  0.08
Output  | 0.00016514 | 0.00016514 | 0.00016514 |   0.0 |  0.00
Modify  | 0.40069    | 0.40069    | 0.40069    |   0.0 |  0.38
Other   |            | 0.05931    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3137 ave        3137 max        3137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118864 ave      118864 max      118864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118864
Ave neighs/atom = 59.432
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.76651491526, Press = 0.303739052330321
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    107000  -10445.374     -10445.374     -10519.608     -10519.608      287.29414      287.29414      28043.617      28043.617     -156.57264     -156.57264    
    108000  -10442.899     -10442.899     -10520.133     -10520.133      298.90372      298.90372      28042.436      28042.436      29.967489      29.967489    
Loop time of 106.346 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.541 hours/ns, 9.403 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    | 105.8      | 105.8      | 105.8      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08361    | 0.08361    | 0.08361    |   0.0 |  0.08
Output  | 0.00016419 | 0.00016419 | 0.00016419 |   0.0 |  0.00
Modify  | 0.40555    | 0.40555    | 0.40555    |   0.0 |  0.38
Other   |            | 0.05978    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3172 ave        3172 max        3172 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118938 ave      118938 max      118938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118938
Ave neighs/atom = 59.469
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.79452524586, Press = 0.0430670638700771
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    108000  -10442.899     -10442.899     -10520.133     -10520.133      298.90372      298.90372      28042.436      28042.436      29.967489      29.967489    
    109000  -10443.146     -10443.146     -10518.456     -10518.456      291.45584      291.45584      28023.732      28023.732      1111.9048      1111.9048    
Loop time of 105.752 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.376 hours/ns, 9.456 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    | 105.21     | 105.21     | 105.21     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082128   | 0.082128   | 0.082128   |   0.0 |  0.08
Output  | 0.00024565 | 0.00024565 | 0.00024565 |   0.0 |  0.00
Modify  | 0.39835    | 0.39835    | 0.39835    |   0.0 |  0.38
Other   |            | 0.05931    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3132 ave        3132 max        3132 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118868 ave      118868 max      118868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118868
Ave neighs/atom = 59.434
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.791295787337, Press = 0.492202359802956
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    109000  -10443.146     -10443.146     -10518.456     -10518.456      291.45584      291.45584      28023.732      28023.732      1111.9048      1111.9048    
    110000  -10446.587     -10446.587     -10521.383     -10521.383      289.46814      289.46814      28071.618      28071.618     -1728.7413     -1728.7413    
Loop time of 105.279 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.244 hours/ns, 9.499 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    | 104.74     | 104.74     | 104.74     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082066   | 0.082066   | 0.082066   |   0.0 |  0.08
Output  | 0.00016407 | 0.00016407 | 0.00016407 |   0.0 |  0.00
Modify  | 0.39365    | 0.39365    | 0.39365    |   0.0 |  0.37
Other   |            | 0.05903    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3153 ave        3153 max        3153 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118994 ave      118994 max      118994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118994
Ave neighs/atom = 59.497
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.790490743982, Press = 0.198924339066764
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    110000  -10446.587     -10446.587     -10521.383     -10521.383      289.46814      289.46814      28071.618      28071.618     -1728.7413     -1728.7413    
    111000  -10443.833     -10443.833     -10520.671     -10520.671      297.37146      297.37146      28022.893      28022.893      1076.4877      1076.4877    
Loop time of 103.452 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.835 ns/day, 28.737 hours/ns, 9.666 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    | 102.92     | 102.92     | 102.92     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081507   | 0.081507   | 0.081507   |   0.0 |  0.08
Output  | 0.00028323 | 0.00028323 | 0.00028323 |   0.0 |  0.00
Modify  | 0.3883     | 0.3883     | 0.3883     |   0.0 |  0.38
Other   |            | 0.05872    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3106 ave        3106 max        3106 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118864 ave      118864 max      118864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118864
Ave neighs/atom = 59.432
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.774196454652, Press = -0.323803183457849
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    111000  -10443.833     -10443.833     -10520.671     -10520.671      297.37146      297.37146      28022.893      28022.893      1076.4877      1076.4877    
    112000  -10448.794     -10448.794     -10523.645     -10523.645      289.68157      289.68157      28010.85       28010.85       1327.4985      1327.4985    
Loop time of 105.748 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.374 hours/ns, 9.456 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    | 105.2      | 105.2      | 105.2      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082307   | 0.082307   | 0.082307   |   0.0 |  0.08
Output  | 0.00019485 | 0.00019485 | 0.00019485 |   0.0 |  0.00
Modify  | 0.40203    | 0.40203    | 0.40203    |   0.0 |  0.38
Other   |            | 0.05973    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3146 ave        3146 max        3146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118910 ave      118910 max      118910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118910
Ave neighs/atom = 59.455
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.767452648655, Press = 0.753648768232158
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    112000  -10448.794     -10448.794     -10523.645     -10523.645      289.68157      289.68157      28010.85       28010.85       1327.4985      1327.4985    
    113000  -10445.223     -10445.223     -10521.408     -10521.408      294.84292      294.84292      28075.83       28075.83      -1953.4041     -1953.4041    
Loop time of 104.44 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.011 hours/ns, 9.575 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    | 103.91     | 103.91     | 103.91     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080427   | 0.080427   | 0.080427   |   0.0 |  0.08
Output  | 0.00016386 | 0.00016386 | 0.00016386 |   0.0 |  0.00
Modify  | 0.39533    | 0.39533    | 0.39533    |   0.0 |  0.38
Other   |            | 0.05886    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3104 ave        3104 max        3104 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118910 ave      118910 max      118910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118910
Ave neighs/atom = 59.455
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.740686320002, Press = 0.0829232840567307
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    113000  -10445.223     -10445.223     -10521.408     -10521.408      294.84292      294.84292      28075.83       28075.83      -1953.4041     -1953.4041    
    114000  -10441.692     -10441.692     -10518.892     -10518.892      298.77221      298.77221      28031.915      28031.915      623.56402      623.56402    
Loop time of 104.2 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.945 hours/ns, 9.597 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.67     | 103.67     | 103.67     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079998   | 0.079998   | 0.079998   |   0.0 |  0.08
Output  | 0.00016416 | 0.00016416 | 0.00016416 |   0.0 |  0.00
Modify  | 0.39286    | 0.39286    | 0.39286    |   0.0 |  0.38
Other   |            | 0.05856    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3085 ave        3085 max        3085 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118786 ave      118786 max      118786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118786
Ave neighs/atom = 59.393
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.753874367461, Press = 0.052060616310872
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    114000  -10441.692     -10441.692     -10518.892     -10518.892      298.77221      298.77221      28031.915      28031.915      623.56402      623.56402    
    115000  -10445.457     -10445.457     -10519.859     -10519.859      287.94164      287.94164      28035.56       28035.56       392.12537      392.12537    
Loop time of 103.183 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.837 ns/day, 28.662 hours/ns, 9.692 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    | 102.66     | 102.66     | 102.66     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079131   | 0.079131   | 0.079131   |   0.0 |  0.08
Output  | 0.00024685 | 0.00024685 | 0.00024685 |   0.0 |  0.00
Modify  | 0.38722    | 0.38722    | 0.38722    |   0.0 |  0.38
Other   |            | 0.05856    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3100 ave        3100 max        3100 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118914 ave      118914 max      118914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118914
Ave neighs/atom = 59.457
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.779961096274, Press = 0.424611327690182
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    115000  -10445.457     -10445.457     -10519.859     -10519.859      287.94164      287.94164      28035.56       28035.56       392.12537      392.12537    
    116000  -10442.756     -10442.756     -10519.76      -10519.76       298.01414      298.01414      28068.35       28068.35      -1403.243      -1403.243     
Loop time of 102.849 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.840 ns/day, 28.569 hours/ns, 9.723 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    | 102.33     | 102.33     | 102.33     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078936   | 0.078936   | 0.078936   |   0.0 |  0.08
Output  | 0.00020586 | 0.00020586 | 0.00020586 |   0.0 |  0.00
Modify  | 0.38321    | 0.38321    | 0.38321    |   0.0 |  0.37
Other   |            | 0.05829    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3086 ave        3086 max        3086 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118970 ave      118970 max      118970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118970
Ave neighs/atom = 59.485
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.792621746813, Press = 0.0140385461676361
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    116000  -10442.756     -10442.756     -10519.76      -10519.76       298.01414      298.01414      28068.35       28068.35      -1403.243      -1403.243     
    117000  -10443.789     -10443.789     -10521.172     -10521.172      299.47987      299.47987      27985.55       27985.55       3021.834       3021.834     
Loop time of 104.372 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 28.992 hours/ns, 9.581 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    | 103.84     | 103.84     | 103.84     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081467   | 0.081467   | 0.081467   |   0.0 |  0.08
Output  | 0.00016628 | 0.00016628 | 0.00016628 |   0.0 |  0.00
Modify  | 0.39446    | 0.39446    | 0.39446    |   0.0 |  0.38
Other   |            | 0.059      |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3138 ave        3138 max        3138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118894 ave      118894 max      118894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118894
Ave neighs/atom = 59.447
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.819866950974, Press = -0.354165457780687
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    117000  -10443.789     -10443.789     -10521.172     -10521.172      299.47987      299.47987      27985.55       27985.55       3021.834       3021.834     
    118000  -10441.944     -10441.944     -10517.282     -10517.282      291.56747      291.56747      28037.507      28037.507      514.64153      514.64153    
Loop time of 103.946 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.874 hours/ns, 9.620 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.42     | 103.42     | 103.42     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08149    | 0.08149    | 0.08149    |   0.0 |  0.08
Output  | 0.00016318 | 0.00016318 | 0.00016318 |   0.0 |  0.00
Modify  | 0.38849    | 0.38849    | 0.38849    |   0.0 |  0.37
Other   |            | 0.05895    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3165 ave        3165 max        3165 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119038 ave      119038 max      119038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119038
Ave neighs/atom = 59.519
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.825849893198, Press = 0.963030178425751
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    118000  -10441.944     -10441.944     -10517.282     -10517.282      291.56747      291.56747      28037.507      28037.507      514.64153      514.64153    
    119000  -10444.6       -10444.6       -10521.013     -10521.013      295.72536      295.72536      28064.289      28064.289     -1330.4001     -1330.4001    
Loop time of 105.881 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.411 hours/ns, 9.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    | 105.34     | 105.34     | 105.34     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082339   | 0.082339   | 0.082339   |   0.0 |  0.08
Output  | 0.00016721 | 0.00016721 | 0.00016721 |   0.0 |  0.00
Modify  | 0.39977    | 0.39977    | 0.39977    |   0.0 |  0.38
Other   |            | 0.05904    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3148 ave        3148 max        3148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119000 ave      119000 max      119000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119000
Ave neighs/atom = 59.5
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.829069772836, Press = -0.0287357139350485
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    119000  -10444.6       -10444.6       -10521.013     -10521.013      295.72536      295.72536      28064.289      28064.289     -1330.4001     -1330.4001    
    120000  -10445.032     -10445.032     -10521.254     -10521.254      294.98795      294.98795      28013.323      28013.323      1296.93        1296.93      
Loop time of 106.4 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.556 hours/ns, 9.399 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    | 105.86     | 105.86     | 105.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082154   | 0.082154   | 0.082154   |   0.0 |  0.08
Output  | 0.00020324 | 0.00020324 | 0.00020324 |   0.0 |  0.00
Modify  | 0.40106    | 0.40106    | 0.40106    |   0.0 |  0.38
Other   |            | 0.05986    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3134 ave        3134 max        3134 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118890 ave      118890 max      118890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118890
Ave neighs/atom = 59.445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.830316398295, Press = 0.165597735684131
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    120000  -10445.032     -10445.032     -10521.254     -10521.254      294.98795      294.98795      28013.323      28013.323      1296.93        1296.93      
    121000  -10445.85      -10445.85      -10522.408     -10522.408      296.28688      296.28688      28051.34       28051.34      -776.43205     -776.43205    
Loop time of 104.18 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.939 hours/ns, 9.599 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    | 103.65     | 103.65     | 103.65     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081498   | 0.081498   | 0.081498   |   0.0 |  0.08
Output  | 0.00022831 | 0.00022831 | 0.00022831 |   0.0 |  0.00
Modify  | 0.39       | 0.39       | 0.39       |   0.0 |  0.37
Other   |            | 0.05839    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3144 ave        3144 max        3144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119000 ave      119000 max      119000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119000
Ave neighs/atom = 59.5
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.816340510215, Press = 0.477999826019304
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    121000  -10445.85      -10445.85      -10522.408     -10522.408      296.28688      296.28688      28051.34       28051.34      -776.43205     -776.43205    
    122000  -10445.626     -10445.626     -10521.5       -10521.5        293.63983      293.63983      28080.094      28080.094     -2216.4643     -2216.4643    
Loop time of 103.294 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.693 hours/ns, 9.681 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    | 102.77     | 102.77     | 102.77     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079708   | 0.079708   | 0.079708   |   0.0 |  0.08
Output  | 0.00016577 | 0.00016577 | 0.00016577 |   0.0 |  0.00
Modify  | 0.38351    | 0.38351    | 0.38351    |   0.0 |  0.37
Other   |            | 0.0582     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3108 ave        3108 max        3108 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118876 ave      118876 max      118876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118876
Ave neighs/atom = 59.438
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.831842113048, Press = -0.554952366262519
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    122000  -10445.626     -10445.626     -10521.5       -10521.5        293.63983      293.63983      28080.094      28080.094     -2216.4643     -2216.4643    
    123000  -10443.78      -10443.78      -10520.195     -10520.195      295.73218      295.73218      27979.931      27979.931      3414.5335      3414.5335    
Loop time of 104.106 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.918 hours/ns, 9.606 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    | 103.57     | 103.57     | 103.57     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081568   | 0.081568   | 0.081568   |   0.0 |  0.08
Output  | 0.00016368 | 0.00016368 | 0.00016368 |   0.0 |  0.00
Modify  | 0.39365    | 0.39365    | 0.39365    |   0.0 |  0.38
Other   |            | 0.05866    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3120 ave        3120 max        3120 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118740 ave      118740 max      118740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118740
Ave neighs/atom = 59.37
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.828430061853, Press = 0.223991775239736
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    123000  -10443.78      -10443.78      -10520.195     -10520.195      295.73218      295.73218      27979.931      27979.931      3414.5335      3414.5335    
    124000  -10447.234     -10447.234     -10521.348     -10521.348      286.82778      286.82778      28053.43       28053.43      -932.86943     -932.86943    
Loop time of 104.192 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.942 hours/ns, 9.598 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    | 103.66     | 103.66     | 103.66     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08079    | 0.08079    | 0.08079    |   0.0 |  0.08
Output  | 0.00016382 | 0.00016382 | 0.00016382 |   0.0 |  0.00
Modify  | 0.39184    | 0.39184    | 0.39184    |   0.0 |  0.38
Other   |            | 0.05835    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3096 ave        3096 max        3096 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119000 ave      119000 max      119000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119000
Ave neighs/atom = 59.5
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.818317742377, Press = 0.586643460267323
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    124000  -10447.234     -10447.234     -10521.348     -10521.348      286.82778      286.82778      28053.43       28053.43      -932.86943     -932.86943    
    125000  -10441.936     -10441.936     -10517.317     -10517.317      291.7314       291.7314       28060.316      28060.316     -717.539       -717.539      
Loop time of 103.251 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.837 ns/day, 28.681 hours/ns, 9.685 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    | 102.72     | 102.72     | 102.72     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079982   | 0.079982   | 0.079982   |   0.0 |  0.08
Output  | 0.00016506 | 0.00016506 | 0.00016506 |   0.0 |  0.00
Modify  | 0.38925    | 0.38925    | 0.38925    |   0.0 |  0.38
Other   |            | 0.0582     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3083 ave        3083 max        3083 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118920 ave      118920 max      118920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118920
Ave neighs/atom = 59.46
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.829778464761, Press = -0.0123540621800259
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    125000  -10441.936     -10441.936     -10517.317     -10517.317      291.7314       291.7314       28060.316      28060.316     -717.539       -717.539      
    126000  -10443.271     -10443.271     -10520.238     -10520.238      297.86773      297.86773      28012.177      28012.177      1559.8691      1559.8691    
Loop time of 105.473 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.298 hours/ns, 9.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    | 104.93     | 104.93     | 104.93     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081907   | 0.081907   | 0.081907   |   0.0 |  0.08
Output  | 0.00016647 | 0.00016647 | 0.00016647 |   0.0 |  0.00
Modify  | 0.40084    | 0.40084    | 0.40084    |   0.0 |  0.38
Other   |            | 0.05943    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3085 ave        3085 max        3085 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118880 ave      118880 max      118880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118880
Ave neighs/atom = 59.44
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.838693788666, Press = 0.22359455623133
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    126000  -10443.271     -10443.271     -10520.238     -10520.238      297.86773      297.86773      28012.177      28012.177      1559.8691      1559.8691    
    127000  -10444.591     -10444.591     -10519.689     -10519.689      290.63782      290.63782      28070.632      28070.632     -1633.567      -1633.567     
Loop time of 104.537 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.038 hours/ns, 9.566 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.01     | 104.01     | 104.01     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081461   | 0.081461   | 0.081461   |   0.0 |  0.08
Output  | 0.00020794 | 0.00020794 | 0.00020794 |   0.0 |  0.00
Modify  | 0.39161    | 0.39161    | 0.39161    |   0.0 |  0.37
Other   |            | 0.05829    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3131 ave        3131 max        3131 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119020 ave      119020 max      119020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119020
Ave neighs/atom = 59.51
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.845095373959, Press = 0.79072245357932
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    127000  -10444.591     -10444.591     -10519.689     -10519.689      290.63782      290.63782      28070.632      28070.632     -1633.567      -1633.567     
    128000  -10445.521     -10445.521     -10521.571     -10521.571      294.32394      294.32394      28082.262      28082.262     -2364.4292     -2364.4292    
Loop time of 100.924 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.856 ns/day, 28.035 hours/ns, 9.908 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    | 100.41     | 100.41     | 100.41     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079476   | 0.079476   | 0.079476   |   0.0 |  0.08
Output  | 0.00050005 | 0.00050005 | 0.00050005 |   0.0 |  0.00
Modify  | 0.37569    | 0.37569    | 0.37569    |   0.0 |  0.37
Other   |            | 0.05732    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3142 ave        3142 max        3142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118788 ave      118788 max      118788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118788
Ave neighs/atom = 59.394
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.843040016851, Press = -0.493140783057099
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    128000  -10445.521     -10445.521     -10521.571     -10521.571      294.32394      294.32394      28082.262      28082.262     -2364.4292     -2364.4292    
    129000  -10443.524     -10443.524     -10520.247     -10520.247      296.92709      296.92709      28002.15       28002.15       2205.8453      2205.8453    
Loop time of 103.938 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.872 hours/ns, 9.621 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    | 103.41     | 103.41     | 103.41     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080467   | 0.080467   | 0.080467   |   0.0 |  0.08
Output  | 0.00016408 | 0.00016408 | 0.00016408 |   0.0 |  0.00
Modify  | 0.38882    | 0.38882    | 0.38882    |   0.0 |  0.37
Other   |            | 0.05844    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3138 ave        3138 max        3138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118854 ave      118854 max      118854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118854
Ave neighs/atom = 59.427
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.836749610383, Press = 0.348330900734358
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    129000  -10443.524     -10443.524     -10520.247     -10520.247      296.92709      296.92709      28002.15       28002.15       2205.8453      2205.8453    
    130000  -10445.626     -10445.626     -10519.311     -10519.311      285.167        285.167        28051.103      28051.103     -529.25749     -529.25749    
Loop time of 103.583 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.773 hours/ns, 9.654 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    | 103.05     | 103.05     | 103.05     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081643   | 0.081643   | 0.081643   |   0.0 |  0.08
Output  | 0.00016478 | 0.00016478 | 0.00016478 |   0.0 |  0.00
Modify  | 0.39153    | 0.39153    | 0.39153    |   0.0 |  0.38
Other   |            | 0.05845    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3151 ave        3151 max        3151 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119036 ave      119036 max      119036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119036
Ave neighs/atom = 59.518
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.824631837223, Press = 0.574628141220618
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    130000  -10445.626     -10445.626     -10519.311     -10519.311      285.167        285.167        28051.103      28051.103     -529.25749     -529.25749    
    131000  -10441.596     -10441.596     -10518.631     -10518.631      298.13121      298.13121      28063.975      28063.975     -946.91621     -946.91621    
Loop time of 102.51 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.843 ns/day, 28.475 hours/ns, 9.755 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    | 101.99     | 101.99     | 101.99     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08018    | 0.08018    | 0.08018    |   0.0 |  0.08
Output  | 0.00016859 | 0.00016859 | 0.00016859 |   0.0 |  0.00
Modify  | 0.3827     | 0.3827     | 0.3827     |   0.0 |  0.37
Other   |            | 0.05782    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3118 ave        3118 max        3118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118918 ave      118918 max      118918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118918
Ave neighs/atom = 59.459
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.830676113887, Press = -0.0115368337801759
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    131000  -10441.596     -10441.596     -10518.631     -10518.631      298.13121      298.13121      28063.975      28063.975     -946.91621     -946.91621    
    132000  -10445.35      -10445.35      -10521.58      -10521.58       295.01943      295.01943      27999.625      27999.625      2262.9804      2262.9804    
Loop time of 103.827 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.841 hours/ns, 9.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    | 103.3      | 103.3      | 103.3      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080571   | 0.080571   | 0.080571   |   0.0 |  0.08
Output  | 0.00016379 | 0.00016379 | 0.00016379 |   0.0 |  0.00
Modify  | 0.38691    | 0.38691    | 0.38691    |   0.0 |  0.37
Other   |            | 0.05817    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3119 ave        3119 max        3119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118918 ave      118918 max      118918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118918
Ave neighs/atom = 59.459
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.847075475548, Press = 0.212652678944755
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    132000  -10445.35      -10445.35      -10521.58      -10521.58       295.01943      295.01943      27999.625      27999.625      2262.9804      2262.9804    
    133000  -10442.351     -10442.351     -10519.05      -10519.05       296.83292      296.83292      28068.438      28068.438     -1318.1341     -1318.1341    
Loop time of 102.542 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.843 ns/day, 28.484 hours/ns, 9.752 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    | 102.02     | 102.02     | 102.02     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080094   | 0.080094   | 0.080094   |   0.0 |  0.08
Output  | 0.00020759 | 0.00020759 | 0.00020759 |   0.0 |  0.00
Modify  | 0.38296    | 0.38296    | 0.38296    |   0.0 |  0.37
Other   |            | 0.05797    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3129 ave        3129 max        3129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119054 ave      119054 max      119054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119054
Ave neighs/atom = 59.527
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.870442487133, Press = 1.024022912596
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    133000  -10442.351     -10442.351     -10519.05      -10519.05       296.83292      296.83292      28068.438      28068.438     -1318.1341     -1318.1341    
    134000  -10443.059     -10443.059     -10520.232     -10520.232      298.6683       298.6683       28066.819      28066.819     -1250.4443     -1250.4443    
Loop time of 104.206 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.946 hours/ns, 9.596 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    | 103.68     | 103.68     | 103.68     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080338   | 0.080338   | 0.080338   |   0.0 |  0.08
Output  | 0.00016594 | 0.00016594 | 0.00016594 |   0.0 |  0.00
Modify  | 0.39017    | 0.39017    | 0.39017    |   0.0 |  0.37
Other   |            | 0.05848    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3117 ave        3117 max        3117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118850 ave      118850 max      118850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118850
Ave neighs/atom = 59.425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.870677122109, Press = -0.0323140033690635
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    134000  -10443.059     -10443.059     -10520.232     -10520.232      298.6683       298.6683       28066.819      28066.819     -1250.4443     -1250.4443    
    135000  -10447.272     -10447.272     -10522.812     -10522.812      292.34833      292.34833      28015.001      28015.001      1243.2791      1243.2791    
Loop time of 103.216 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.837 ns/day, 28.671 hours/ns, 9.688 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    | 102.69     | 102.69     | 102.69     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079573   | 0.079573   | 0.079573   |   0.0 |  0.08
Output  | 0.00016646 | 0.00016646 | 0.00016646 |   0.0 |  0.00
Modify  | 0.3862     | 0.3862     | 0.3862     |   0.0 |  0.37
Other   |            | 0.05842    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3094 ave        3094 max        3094 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118888 ave      118888 max      118888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118888
Ave neighs/atom = 59.444
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.867905109537, Press = 0.249631154001778
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    135000  -10447.272     -10447.272     -10522.812     -10522.812      292.34833      292.34833      28015.001      28015.001      1243.2791      1243.2791    
    136000  -10443.693     -10443.693     -10518.072     -10518.072      287.85438      287.85438      28054.02       28054.02      -574.537       -574.537      
Loop time of 105.374 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.271 hours/ns, 9.490 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.84     | 104.84     | 104.84     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08161    | 0.08161    | 0.08161    |   0.0 |  0.08
Output  | 0.00022508 | 0.00022508 | 0.00022508 |   0.0 |  0.00
Modify  | 0.39742    | 0.39742    | 0.39742    |   0.0 |  0.38
Other   |            | 0.05892    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3129 ave        3129 max        3129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118996 ave      118996 max      118996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118996
Ave neighs/atom = 59.498
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.850111542103, Press = 0.516054696068628
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    136000  -10443.693     -10443.693     -10518.072     -10518.072      287.85438      287.85438      28054.02       28054.02      -574.537       -574.537      
    137000  -10445.008     -10445.008     -10519.789     -10519.789      289.41049      289.41049      28063.504      28063.504     -1205.4525     -1205.4525    
Loop time of 103.697 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.805 hours/ns, 9.643 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    | 103.17     | 103.17     | 103.17     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08004    | 0.08004    | 0.08004    |   0.0 |  0.08
Output  | 0.00021304 | 0.00021304 | 0.00021304 |   0.0 |  0.00
Modify  | 0.38722    | 0.38722    | 0.38722    |   0.0 |  0.37
Other   |            | 0.05904    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3125 ave        3125 max        3125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119024 ave      119024 max      119024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119024
Ave neighs/atom = 59.512
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.852337326986, Press = -0.107354864239712
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    137000  -10445.008     -10445.008     -10519.789     -10519.789      289.41049      289.41049      28063.504      28063.504     -1205.4525     -1205.4525    
    138000  -10442.412     -10442.412     -10519.689     -10519.689      299.07271      299.07271      27977.137      27977.137      3637.5089      3637.5089    
Loop time of 104.188 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.941 hours/ns, 9.598 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    | 103.65     | 103.65     | 103.65     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082115   | 0.082115   | 0.082115   |   0.0 |  0.08
Output  | 0.0001683  | 0.0001683  | 0.0001683  |   0.0 |  0.00
Modify  | 0.39185    | 0.39185    | 0.39185    |   0.0 |  0.38
Other   |            | 0.05917    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3146 ave        3146 max        3146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118914 ave      118914 max      118914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118914
Ave neighs/atom = 59.457
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.856427322021, Press = 0.32059949813416
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    138000  -10442.412     -10442.412     -10519.689     -10519.689      299.07271      299.07271      27977.137      27977.137      3637.5089      3637.5089    
    139000  -10445.688     -10445.688     -10519.563     -10519.563      285.90513      285.90513      28053.416      28053.416     -383.5937      -383.5937     
Loop time of 103.502 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.835 ns/day, 28.750 hours/ns, 9.662 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    | 102.97     | 102.97     | 102.97     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081427   | 0.081427   | 0.081427   |   0.0 |  0.08
Output  | 0.00017001 | 0.00017001 | 0.00017001 |   0.0 |  0.00
Modify  | 0.38681    | 0.38681    | 0.38681    |   0.0 |  0.37
Other   |            | 0.05839    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3162 ave        3162 max        3162 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119186 ave      119186 max      119186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119186
Ave neighs/atom = 59.593
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.845559692314, Press = 0.702931657241209
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    139000  -10445.688     -10445.688     -10519.563     -10519.563      285.90513      285.90513      28053.416      28053.416     -383.5937      -383.5937     
    140000  -10444.899     -10444.899     -10519.753     -10519.753      289.69463      289.69463      28049.763      28049.763     -292.07578     -292.07578    
Loop time of 103.781 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.828 hours/ns, 9.636 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    | 103.25     | 103.25     | 103.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080855   | 0.080855   | 0.080855   |   0.0 |  0.08
Output  | 0.00016502 | 0.00016502 | 0.00016502 |   0.0 |  0.00
Modify  | 0.38789    | 0.38789    | 0.38789    |   0.0 |  0.37
Other   |            | 0.05864    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3131 ave        3131 max        3131 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118876 ave      118876 max      118876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118876
Ave neighs/atom = 59.438
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.838576395826, Press = 0.138409444142075
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    140000  -10444.899     -10444.899     -10519.753     -10519.753      289.69463      289.69463      28049.763      28049.763     -292.07578     -292.07578    
    141000  -10444.306     -10444.306     -10520.59      -10520.59       295.23003      295.23003      28028.888      28028.888      706.02532      706.02532    
Loop time of 102.743 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.841 ns/day, 28.540 hours/ns, 9.733 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.22     | 102.22     | 102.22     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079537   | 0.079537   | 0.079537   |   0.0 |  0.08
Output  | 0.00019645 | 0.00019645 | 0.00019645 |   0.0 |  0.00
Modify  | 0.38202    | 0.38202    | 0.38202    |   0.0 |  0.37
Other   |            | 0.05792    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3116 ave        3116 max        3116 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118964 ave      118964 max      118964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118964
Ave neighs/atom = 59.482
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.820934402473, Press = 0.363847184026514
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    141000  -10444.306     -10444.306     -10520.59      -10520.59       295.23003      295.23003      28028.888      28028.888      706.02532      706.02532    
    142000  -10447.024     -10447.024     -10520.756     -10520.756      285.34932      285.34932      28063.795      28063.795     -1241.9604     -1241.9604    
Loop time of 105.433 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.287 hours/ns, 9.485 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    | 104.89     | 104.89     | 104.89     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082847   | 0.082847   | 0.082847   |   0.0 |  0.08
Output  | 0.00016522 | 0.00016522 | 0.00016522 |   0.0 |  0.00
Modify  | 0.39857    | 0.39857    | 0.39857    |   0.0 |  0.38
Other   |            | 0.05914    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3165 ave        3165 max        3165 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118932 ave      118932 max      118932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118932
Ave neighs/atom = 59.466
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.818287857737, Press = 0.336861494970429
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    142000  -10447.024     -10447.024     -10520.756     -10520.756      285.34932      285.34932      28063.795      28063.795     -1241.9604     -1241.9604    
    143000  -10443.048     -10443.048     -10520.795     -10520.795      300.88796      300.88796      28035.355      28035.355      482.96077      482.96077    
Loop time of 103.431 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.835 ns/day, 28.731 hours/ns, 9.668 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    | 102.9      | 102.9      | 102.9      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080504   | 0.080504   | 0.080504   |   0.0 |  0.08
Output  | 0.00016519 | 0.00016519 | 0.00016519 |   0.0 |  0.00
Modify  | 0.39079    | 0.39079    | 0.39079    |   0.0 |  0.38
Other   |            | 0.0586     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3113 ave        3113 max        3113 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118886 ave      118886 max      118886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118886
Ave neighs/atom = 59.443
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.808271275359, Press = -0.246478870012711
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    143000  -10443.048     -10443.048     -10520.795     -10520.795      300.88796      300.88796      28035.355      28035.355      482.96077      482.96077    
    144000  -10444.061     -10444.061     -10520.037     -10520.037      294.03332      294.03332      28001.138      28001.138      2390.0449      2390.0449    
Loop time of 105.159 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.211 hours/ns, 9.509 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    | 104.62     | 104.62     | 104.62     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081464   | 0.081464   | 0.081464   |   0.0 |  0.08
Output  | 0.00026795 | 0.00026795 | 0.00026795 |   0.0 |  0.00
Modify  | 0.39582    | 0.39582    | 0.39582    |   0.0 |  0.38
Other   |            | 0.05859    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3110 ave        3110 max        3110 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118972 ave      118972 max      118972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118972
Ave neighs/atom = 59.486
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.8124048151, Press = 0.67350428684825
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    144000  -10444.061     -10444.061     -10520.037     -10520.037      294.03332      294.03332      28001.138      28001.138      2390.0449      2390.0449    
    145000  -10444.496     -10444.496     -10519.385     -10519.385      289.82596      289.82596      28086.482      28086.482     -2223.733      -2223.733     
Loop time of 103.581 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.772 hours/ns, 9.654 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    | 103.05     | 103.05     | 103.05     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079835   | 0.079835   | 0.079835   |   0.0 |  0.08
Output  | 0.00016566 | 0.00016566 | 0.00016566 |   0.0 |  0.00
Modify  | 0.38817    | 0.38817    | 0.38817    |   0.0 |  0.37
Other   |            | 0.0581     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3100 ave        3100 max        3100 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119058 ave      119058 max      119058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119058
Ave neighs/atom = 59.529
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.837527828821, Press = 0.436794306640156
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    145000  -10444.496     -10444.496     -10519.385     -10519.385      289.82596      289.82596      28086.482      28086.482     -2223.733      -2223.733     
    146000  -10445.691     -10445.691     -10520.243     -10520.243      288.52476      288.52476      28034.204      28034.204      438.84494      438.84494    
Loop time of 103.659 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.794 hours/ns, 9.647 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    | 103.13     | 103.13     | 103.13     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08027    | 0.08027    | 0.08027    |   0.0 |  0.08
Output  | 0.00016814 | 0.00016814 | 0.00016814 |   0.0 |  0.00
Modify  | 0.38956    | 0.38956    | 0.38956    |   0.0 |  0.38
Other   |            | 0.05817    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3102 ave        3102 max        3102 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118900 ave      118900 max      118900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118900
Ave neighs/atom = 59.45
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.837896495438, Press = -0.0480585454129548
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    146000  -10445.691     -10445.691     -10520.243     -10520.243      288.52476      288.52476      28034.204      28034.204      438.84494      438.84494    
    147000  -10446.193     -10446.193     -10521.681     -10521.681      292.14339      292.14339      28021.822      28021.822      1020.9566      1020.9566    
Loop time of 102.988 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.608 hours/ns, 9.710 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    | 102.46     | 102.46     | 102.46     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080561   | 0.080561   | 0.080561   |   0.0 |  0.08
Output  | 0.00016307 | 0.00016307 | 0.00016307 |   0.0 |  0.00
Modify  | 0.38669    | 0.38669    | 0.38669    |   0.0 |  0.38
Other   |            | 0.05847    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3128 ave        3128 max        3128 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118944 ave      118944 max      118944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118944
Ave neighs/atom = 59.472
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.83491552714, Press = 0.490923060370242
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    147000  -10446.193     -10446.193     -10521.681     -10521.681      292.14339      292.14339      28021.822      28021.822      1020.9566      1020.9566    
    148000  -10446.789     -10446.789     -10520.046     -10520.046      283.5115       283.5115       28072.715      28072.715     -1605.2993     -1605.2993    
Loop time of 103.219 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.837 ns/day, 28.672 hours/ns, 9.688 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    | 102.69     | 102.69     | 102.69     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080521   | 0.080521   | 0.080521   |   0.0 |  0.08
Output  | 0.00016434 | 0.00016434 | 0.00016434 |   0.0 |  0.00
Modify  | 0.38572    | 0.38572    | 0.38572    |   0.0 |  0.37
Other   |            | 0.05821    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3122 ave        3122 max        3122 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118924 ave      118924 max      118924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118924
Ave neighs/atom = 59.462
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.818792580983, Press = 0.40128729525184
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    148000  -10446.789     -10446.789     -10520.046     -10520.046      283.5115       283.5115       28072.715      28072.715     -1605.2993     -1605.2993    
    149000  -10443.803     -10443.803     -10519.817     -10519.817      294.1851       294.1851       28032.348      28032.348      651.28435      651.28435    
Loop time of 103.645 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.790 hours/ns, 9.648 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.12     | 103.12     | 103.12     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079949   | 0.079949   | 0.079949   |   0.0 |  0.08
Output  | 0.00016531 | 0.00016531 | 0.00016531 |   0.0 |  0.00
Modify  | 0.38853    | 0.38853    | 0.38853    |   0.0 |  0.37
Other   |            | 0.05848    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3092 ave        3092 max        3092 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118874 ave      118874 max      118874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118874
Ave neighs/atom = 59.437
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.81146719493, Press = -0.216566056462359
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    149000  -10443.803     -10443.803     -10519.817     -10519.817      294.1851       294.1851       28032.348      28032.348      651.28435      651.28435    
    150000  -10450.142     -10450.142     -10523.125     -10523.125      282.45129      282.45129      27988.321      27988.321      2588.1911      2588.1911    
Loop time of 103.028 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.619 hours/ns, 9.706 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    | 102.5      | 102.5      | 102.5      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080801   | 0.080801   | 0.080801   |   0.0 |  0.08
Output  | 0.00016409 | 0.00016409 | 0.00016409 |   0.0 |  0.00
Modify  | 0.38509    | 0.38509    | 0.38509    |   0.0 |  0.37
Other   |            | 0.05865    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3148 ave        3148 max        3148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118984 ave      118984 max      118984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118984
Ave neighs/atom = 59.492
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.796720571898, Press = 0.728425066850674
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    150000  -10450.142     -10450.142     -10523.125     -10523.125      282.45129      282.45129      27988.321      27988.321      2588.1911      2588.1911    
    151000  -10444.105     -10444.105     -10520.892     -10520.892      297.17117      297.17117      28074.605      28074.605     -1817.8233     -1817.8233    
Loop time of 103.682 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.801 hours/ns, 9.645 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    | 103.16     | 103.16     | 103.16     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080578   | 0.080578   | 0.080578   |   0.0 |  0.08
Output  | 0.0001637  | 0.0001637  | 0.0001637  |   0.0 |  0.00
Modify  | 0.38688    | 0.38688    | 0.38688    |   0.0 |  0.37
Other   |            | 0.05907    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3127 ave        3127 max        3127 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118944 ave      118944 max      118944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118944
Ave neighs/atom = 59.472
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.792429674806, Press = 0.401619997529381
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    151000  -10444.105     -10444.105     -10520.892     -10520.892      297.17117      297.17117      28074.605      28074.605     -1817.8233     -1817.8233    
    152000  -10446.29      -10446.29      -10521.884     -10521.884      292.55416      292.55416      28034.904      28034.904      278.56731      278.56731    
Loop time of 102.82 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.840 ns/day, 28.561 hours/ns, 9.726 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    | 102.3      | 102.3      | 102.3      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080046   | 0.080046   | 0.080046   |   0.0 |  0.08
Output  | 0.00016406 | 0.00016406 | 0.00016406 |   0.0 |  0.00
Modify  | 0.38621    | 0.38621    | 0.38621    |   0.0 |  0.38
Other   |            | 0.05843    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3111 ave        3111 max        3111 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118830 ave      118830 max      118830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118830
Ave neighs/atom = 59.415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.782365872731, Press = 0.0935925196740034
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    152000  -10446.29      -10446.29      -10521.884     -10521.884      292.55416      292.55416      28034.904      28034.904      278.56731      278.56731    
    153000  -10444.686     -10444.686     -10520.776     -10520.776      294.47769      294.47769      28028.988      28028.988      741.72145      741.72145    
Loop time of 103.759 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.822 hours/ns, 9.638 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    | 103.22     | 103.22     | 103.22     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082      | 0.082      | 0.082      |   0.0 |  0.08
Output  | 0.00023078 | 0.00023078 | 0.00023078 |   0.0 |  0.00
Modify  | 0.39589    | 0.39589    | 0.39589    |   0.0 |  0.38
Other   |            | 0.05888    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3146 ave        3146 max        3146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118958 ave      118958 max      118958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118958
Ave neighs/atom = 59.479
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.77463438983, Press = 0.359277679406501
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    153000  -10444.686     -10444.686     -10520.776     -10520.776      294.47769      294.47769      28028.988      28028.988      741.72145      741.72145    
    154000  -10444.485     -10444.485     -10519.055     -10519.055      288.5945       288.5945       28080.718      28080.718     -2044.323      -2044.323     
Loop time of 103.413 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.835 ns/day, 28.726 hours/ns, 9.670 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    | 102.88     | 102.88     | 102.88     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081421   | 0.081421   | 0.081421   |   0.0 |  0.08
Output  | 0.00016292 | 0.00016292 | 0.00016292 |   0.0 |  0.00
Modify  | 0.39293    | 0.39293    | 0.39293    |   0.0 |  0.38
Other   |            | 0.05781    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3138 ave        3138 max        3138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118964 ave      118964 max      118964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118964
Ave neighs/atom = 59.482
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.782611515845, Press = 0.359675591277855
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    154000  -10444.485     -10444.485     -10519.055     -10519.055      288.5945       288.5945       28080.718      28080.718     -2044.323      -2044.323     
    155000  -10442.256     -10442.256     -10517.163     -10517.163      289.89734      289.89734      28046.004      28046.004     -19.839536     -19.839536    
Loop time of 103.582 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.773 hours/ns, 9.654 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    | 103.06     | 103.06     | 103.06     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079841   | 0.079841   | 0.079841   |   0.0 |  0.08
Output  | 0.00020312 | 0.00020312 | 0.00020312 |   0.0 |  0.00
Modify  | 0.38831    | 0.38831    | 0.38831    |   0.0 |  0.37
Other   |            | 0.05828    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3129 ave        3129 max        3129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118826 ave      118826 max      118826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118826
Ave neighs/atom = 59.413
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.78007528001, Press = -0.365015218911091
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    155000  -10442.256     -10442.256     -10517.163     -10517.163      289.89734      289.89734      28046.004      28046.004     -19.839536     -19.839536    
    156000  -10444.658     -10444.658     -10520.801     -10520.801      294.6824       294.6824       28001.334      28001.334      2160.9205      2160.9205    
Loop time of 103.821 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.839 hours/ns, 9.632 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    | 103.29     | 103.29     | 103.29     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081385   | 0.081385   | 0.081385   |   0.0 |  0.08
Output  | 0.00016404 | 0.00016404 | 0.00016404 |   0.0 |  0.00
Modify  | 0.38885    | 0.38885    | 0.38885    |   0.0 |  0.37
Other   |            | 0.05866    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3151 ave        3151 max        3151 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118986 ave      118986 max      118986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118986
Ave neighs/atom = 59.493
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.799096835675, Press = 0.530697072040666
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    156000  -10444.658     -10444.658     -10520.801     -10520.801      294.6824       294.6824       28001.334      28001.334      2160.9205      2160.9205    
    157000  -10447.349     -10447.349     -10522.634     -10522.634      291.36178      291.36178      28062.476      28062.476     -1257.4115     -1257.4115    
Loop time of 106.074 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.465 hours/ns, 9.427 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    | 105.53     | 105.53     | 105.53     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081982   | 0.081982   | 0.081982   |   0.0 |  0.08
Output  | 0.00021835 | 0.00021835 | 0.00021835 |   0.0 |  0.00
Modify  | 0.40207    | 0.40207    | 0.40207    |   0.0 |  0.38
Other   |            | 0.05949    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3121 ave        3121 max        3121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119076 ave      119076 max      119076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119076
Ave neighs/atom = 59.538
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.784354488942, Press = 0.449352421023717
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    157000  -10447.349     -10447.349     -10522.634     -10522.634      291.36178      291.36178      28062.476      28062.476     -1257.4115     -1257.4115    
    158000  -10444.567     -10444.567     -10520.126     -10520.126      292.41879      292.41879      28040.39       28040.39       0.89191154     0.89191154   
Loop time of 104.193 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.942 hours/ns, 9.598 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    | 103.66     | 103.66     | 103.66     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081233   | 0.081233   | 0.081233   |   0.0 |  0.08
Output  | 0.00026455 | 0.00026455 | 0.00026455 |   0.0 |  0.00
Modify  | 0.39335    | 0.39335    | 0.39335    |   0.0 |  0.38
Other   |            | 0.05872    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3117 ave        3117 max        3117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118840 ave      118840 max      118840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118840
Ave neighs/atom = 59.42
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.781864236872, Press = 0.0533354568893442
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    158000  -10444.567     -10444.567     -10520.126     -10520.126      292.41879      292.41879      28040.39       28040.39       0.89191154     0.89191154   
    159000  -10445.128     -10445.128     -10521.237     -10521.237      294.55029      294.55029      28015.361      28015.361      1330.5602      1330.5602    
Loop time of 103.21 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.837 ns/day, 28.669 hours/ns, 9.689 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    | 102.69     | 102.69     | 102.69     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080109   | 0.080109   | 0.080109   |   0.0 |  0.08
Output  | 0.00016445 | 0.00016445 | 0.00016445 |   0.0 |  0.00
Modify  | 0.38675    | 0.38675    | 0.38675    |   0.0 |  0.37
Other   |            | 0.0581     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3114 ave        3114 max        3114 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118980 ave      118980 max      118980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118980
Ave neighs/atom = 59.49
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.776851935043, Press = 0.427260574971793
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    159000  -10445.128     -10445.128     -10521.237     -10521.237      294.55029      294.55029      28015.361      28015.361      1330.5602      1330.5602    
    160000  -10441.039     -10441.039     -10517.178     -10517.178      294.66729      294.66729      28121.907      28121.907     -4137.8223     -4137.8223    
Loop time of 102.312 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.844 ns/day, 28.420 hours/ns, 9.774 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    | 101.79     | 101.79     | 101.79     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07969    | 0.07969    | 0.07969    |   0.0 |  0.08
Output  | 0.00016487 | 0.00016487 | 0.00016487 |   0.0 |  0.00
Modify  | 0.384      | 0.384      | 0.384      |   0.0 |  0.38
Other   |            | 0.05776    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3143 ave        3143 max        3143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119008 ave      119008 max      119008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119008
Ave neighs/atom = 59.504
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.782418030846, Press = 0.508675418632624
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    160000  -10441.039     -10441.039     -10517.178     -10517.178      294.66729      294.66729      28121.907      28121.907     -4137.8223     -4137.8223    
    161000  -10445.631     -10445.631     -10521.352     -10521.352      293.04719      293.04719      28034.476      28034.476      244.13934      244.13934    
Loop time of 103 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.611 hours/ns, 9.709 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    | 102.47     | 102.47     | 102.47     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081322   | 0.081322   | 0.081322   |   0.0 |  0.08
Output  | 0.00016521 | 0.00016521 | 0.00016521 |   0.0 |  0.00
Modify  | 0.38601    | 0.38601    | 0.38601    |   0.0 |  0.37
Other   |            | 0.05834    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3156 ave        3156 max        3156 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118828 ave      118828 max      118828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118828
Ave neighs/atom = 59.414
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.780408567866, Press = -0.1529618858536
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    161000  -10445.631     -10445.631     -10521.352     -10521.352      293.04719      293.04719      28034.476      28034.476      244.13934      244.13934    
    162000  -10443.836     -10443.836     -10519.676     -10519.676      293.50856      293.50856      28016.84       28016.84       1478.809       1478.809     
Loop time of 103.953 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.876 hours/ns, 9.620 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.42     | 103.42     | 103.42     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081842   | 0.081842   | 0.081842   |   0.0 |  0.08
Output  | 0.00020767 | 0.00020767 | 0.00020767 |   0.0 |  0.00
Modify  | 0.38982    | 0.38982    | 0.38982    |   0.0 |  0.37
Other   |            | 0.05888    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3182 ave        3182 max        3182 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118920 ave      118920 max      118920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118920
Ave neighs/atom = 59.46
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.787366930616, Press = 0.563428646009312
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    162000  -10443.836     -10443.836     -10519.676     -10519.676      293.50856      293.50856      28016.84       28016.84       1478.809       1478.809     
    163000  -10440.944     -10440.944     -10518.199     -10518.199      298.98565      298.98565      28080.503      28080.503     -1960.5842     -1960.5842    
Loop time of 103.86 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.850 hours/ns, 9.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    | 103.33     | 103.33     | 103.33     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080814   | 0.080814   | 0.080814   |   0.0 |  0.08
Output  | 0.00021283 | 0.00021283 | 0.00021283 |   0.0 |  0.00
Modify  | 0.3883     | 0.3883     | 0.3883     |   0.0 |  0.37
Other   |            | 0.05842    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3143 ave        3143 max        3143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118998 ave      118998 max      118998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118998
Ave neighs/atom = 59.499
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.787009298914, Press = 0.360692643657884
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    163000  -10440.944     -10440.944     -10518.199     -10518.199      298.98565      298.98565      28080.503      28080.503     -1960.5842     -1960.5842    
    164000  -10445.345     -10445.345     -10519.227     -10519.227      285.92867      285.92867      28022.107      28022.107      1223.6416      1223.6416    
Loop time of 104.685 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.079 hours/ns, 9.552 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    | 104.16     | 104.16     | 104.16     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080884   | 0.080884   | 0.080884   |   0.0 |  0.08
Output  | 0.00016569 | 0.00016569 | 0.00016569 |   0.0 |  0.00
Modify  | 0.38894    | 0.38894    | 0.38894    |   0.0 |  0.37
Other   |            | 0.05883    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3125 ave        3125 max        3125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118880 ave      118880 max      118880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118880
Ave neighs/atom = 59.44
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.798527540852, Press = 0.0356883237270172
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    164000  -10445.345     -10445.345     -10519.227     -10519.227      285.92867      285.92867      28022.107      28022.107      1223.6416      1223.6416    
    165000  -10441.395     -10441.395     -10518.414     -10518.414      298.07045      298.07045      28027.264      28027.264      1291.1485      1291.1485    
Loop time of 102.496 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.843 ns/day, 28.471 hours/ns, 9.757 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    | 101.97     | 101.97     | 101.97     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079691   | 0.079691   | 0.079691   |   0.0 |  0.08
Output  | 0.00016457 | 0.00016457 | 0.00016457 |   0.0 |  0.00
Modify  | 0.38308    | 0.38308    | 0.38308    |   0.0 |  0.37
Other   |            | 0.05814    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3141 ave        3141 max        3141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118998 ave      118998 max      118998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118998
Ave neighs/atom = 59.499
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.816606341205, Press = 0.575969866886442
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    165000  -10441.395     -10441.395     -10518.414     -10518.414      298.07045      298.07045      28027.264      28027.264      1291.1485      1291.1485    
    166000  -10446.189     -10446.189     -10520.756     -10520.756      288.58216      288.58216      28079.445      28079.445     -2007.2325     -2007.2325    
Loop time of 103.331 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.703 hours/ns, 9.678 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    | 102.8      | 102.8      | 102.8      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080112   | 0.080112   | 0.080112   |   0.0 |  0.08
Output  | 0.00045674 | 0.00045674 | 0.00045674 |   0.0 |  0.00
Modify  | 0.38744    | 0.38744    | 0.38744    |   0.0 |  0.37
Other   |            | 0.05869    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3113 ave        3113 max        3113 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118884 ave      118884 max      118884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118884
Ave neighs/atom = 59.442
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.822415015747, Press = 0.31695434138156
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    166000  -10446.189     -10446.189     -10520.756     -10520.756      288.58216      288.58216      28079.445      28079.445     -2007.2325     -2007.2325    
    167000  -10444.272     -10444.272     -10518.156     -10518.156      285.93885      285.93885      28021.264      28021.264      1386.4286      1386.4286    
Loop time of 105.34 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.261 hours/ns, 9.493 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    | 104.8      | 104.8      | 104.8      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08238    | 0.08238    | 0.08238    |   0.0 |  0.08
Output  | 0.0001673  | 0.0001673  | 0.0001673  |   0.0 |  0.00
Modify  | 0.39843    | 0.39843    | 0.39843    |   0.0 |  0.38
Other   |            | 0.05905    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3131 ave        3131 max        3131 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118810 ave      118810 max      118810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118810
Ave neighs/atom = 59.405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.837771858538, Press = -0.0923184875029932
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    167000  -10444.272     -10444.272     -10518.156     -10518.156      285.93885      285.93885      28021.264      28021.264      1386.4286      1386.4286    
    168000  -10442.786     -10442.786     -10520.741     -10520.741      301.69546      301.69546      28028.241      28028.241      794.68857      794.68857    
Loop time of 103.272 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.837 ns/day, 28.687 hours/ns, 9.683 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    | 102.74     | 102.74     | 102.74     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080457   | 0.080457   | 0.080457   |   0.0 |  0.08
Output  | 0.00025158 | 0.00025158 | 0.00025158 |   0.0 |  0.00
Modify  | 0.38896    | 0.38896    | 0.38896    |   0.0 |  0.38
Other   |            | 0.05884    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3125 ave        3125 max        3125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118962 ave      118962 max      118962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118962
Ave neighs/atom = 59.481
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.846190765818, Press = 0.61168942287147
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    168000  -10442.786     -10442.786     -10520.741     -10520.741      301.69546      301.69546      28028.241      28028.241      794.68857      794.68857    
    169000  -10447.251     -10447.251     -10520.561     -10520.561      283.71872      283.71872      28057.984      28057.984     -879.95794     -879.95794    
Loop time of 103.543 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.762 hours/ns, 9.658 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    | 103.02     | 103.02     | 103.02     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080854   | 0.080854   | 0.080854   |   0.0 |  0.08
Output  | 0.00016457 | 0.00016457 | 0.00016457 |   0.0 |  0.00
Modify  | 0.38739    | 0.38739    | 0.38739    |   0.0 |  0.37
Other   |            | 0.05875    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3136 ave        3136 max        3136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118972 ave      118972 max      118972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118972
Ave neighs/atom = 59.486
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.847838509771, Press = 0.234363419927888
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    169000  -10447.251     -10447.251     -10520.561     -10520.561      283.71872      283.71872      28057.984      28057.984     -879.95794     -879.95794    
    170000  -10444.356     -10444.356     -10519.565     -10519.565      291.066        291.066        28031.031      28031.031      745.7551       745.7551     
Loop time of 105.661 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.350 hours/ns, 9.464 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    | 105.12     | 105.12     | 105.12     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083017   | 0.083017   | 0.083017   |   0.0 |  0.08
Output  | 0.00016558 | 0.00016558 | 0.00016558 |   0.0 |  0.00
Modify  | 0.40226    | 0.40226    | 0.40226    |   0.0 |  0.38
Other   |            | 0.05953    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3154 ave        3154 max        3154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118788 ave      118788 max      118788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118788
Ave neighs/atom = 59.394
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.845175830268, Press = 0.271975198977752
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    170000  -10444.356     -10444.356     -10519.565     -10519.565      291.066        291.066        28031.031      28031.031      745.7551       745.7551     
    171000  -10445.114     -10445.114     -10518.945     -10518.945      285.73555      285.73555      28042.536      28042.536      87.18613       87.18613     
Loop time of 104.87 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.131 hours/ns, 9.536 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    | 104.33     | 104.33     | 104.33     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081992   | 0.081992   | 0.081992   |   0.0 |  0.08
Output  | 0.00022966 | 0.00022966 | 0.00022966 |   0.0 |  0.00
Modify  | 0.39568    | 0.39568    | 0.39568    |   0.0 |  0.38
Other   |            | 0.05914    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3153 ave        3153 max        3153 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118902 ave      118902 max      118902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118902
Ave neighs/atom = 59.451
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.828665499881, Press = 0.39135983209214
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    171000  -10445.114     -10445.114     -10518.945     -10518.945      285.73555      285.73555      28042.536      28042.536      87.18613       87.18613     
    172000  -10446.687     -10446.687     -10523.177     -10523.177      296.02181      296.02181      28055.166      28055.166     -1029.1884     -1029.1884    
Loop time of 104.395 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 28.999 hours/ns, 9.579 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    | 103.86     | 103.86     | 103.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080949   | 0.080949   | 0.080949   |   0.0 |  0.08
Output  | 0.00020439 | 0.00020439 | 0.00020439 |   0.0 |  0.00
Modify  | 0.39127    | 0.39127    | 0.39127    |   0.0 |  0.37
Other   |            | 0.05847    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3151 ave        3151 max        3151 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118932 ave      118932 max      118932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118932
Ave neighs/atom = 59.466
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.831408248936, Press = 0.0703983058666463
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    172000  -10446.687     -10446.687     -10523.177     -10523.177      296.02181      296.02181      28055.166      28055.166     -1029.1884     -1029.1884    
    173000  -10442.562     -10442.562     -10519.371     -10519.371      297.26044      297.26044      27996.844      27996.844      2524.0199      2524.0199    
Loop time of 106.07 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.464 hours/ns, 9.428 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    | 105.52     | 105.52     | 105.52     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082448   | 0.082448   | 0.082448   |   0.0 |  0.08
Output  | 0.00016455 | 0.00016455 | 0.00016455 |   0.0 |  0.00
Modify  | 0.40252    | 0.40252    | 0.40252    |   0.0 |  0.38
Other   |            | 0.05976    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3142 ave        3142 max        3142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118866 ave      118866 max      118866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118866
Ave neighs/atom = 59.433
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.84382497657, Press = 0.407613578942955
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    173000  -10442.562     -10442.562     -10519.371     -10519.371      297.26044      297.26044      27996.844      27996.844      2524.0199      2524.0199    
    174000  -10446.046     -10446.046     -10520.941     -10520.941      289.84969      289.84969      28075.998      28075.998     -2018.3258     -2018.3258    
Loop time of 105.28 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.244 hours/ns, 9.499 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    | 104.74     | 104.74     | 104.74     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082697   | 0.082697   | 0.082697   |   0.0 |  0.08
Output  | 0.00016444 | 0.00016444 | 0.00016444 |   0.0 |  0.00
Modify  | 0.39766    | 0.39766    | 0.39766    |   0.0 |  0.38
Other   |            | 0.05997    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3161 ave        3161 max        3161 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119032 ave      119032 max      119032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119032
Ave neighs/atom = 59.516
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.843411904057, Press = 0.533941609725243
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    174000  -10446.046     -10446.046     -10520.941     -10520.941      289.84969      289.84969      28075.998      28075.998     -2018.3258     -2018.3258    
    175000  -10443.221     -10443.221     -10518.866     -10518.866      292.7552       292.7552       28052.803      28052.803     -517.03835     -517.03835    
Loop time of 103.335 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.704 hours/ns, 9.677 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    | 102.81     | 102.81     | 102.81     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080952   | 0.080952   | 0.080952   |   0.0 |  0.08
Output  | 0.0001646  | 0.0001646  | 0.0001646  |   0.0 |  0.00
Modify  | 0.38794    | 0.38794    | 0.38794    |   0.0 |  0.38
Other   |            | 0.05876    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3129 ave        3129 max        3129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118844 ave      118844 max      118844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118844
Ave neighs/atom = 59.422
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.831697541361, Press = -0.0456626355684714
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    175000  -10443.221     -10443.221     -10518.866     -10518.866      292.7552       292.7552       28052.803      28052.803     -517.03835     -517.03835    
    176000  -10442.751     -10442.751     -10519.085     -10519.085      295.42033      295.42033      28026.379      28026.379      865.76772      865.76772    
Loop time of 103.834 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.843 hours/ns, 9.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    | 103.31     | 103.31     | 103.31     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080452   | 0.080452   | 0.080452   |   0.0 |  0.08
Output  | 0.00019816 | 0.00019816 | 0.00019816 |   0.0 |  0.00
Modify  | 0.38964    | 0.38964    | 0.38964    |   0.0 |  0.38
Other   |            | 0.05911    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3132 ave        3132 max        3132 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118900 ave      118900 max      118900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118900
Ave neighs/atom = 59.45
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.836851204325, Press = 0.355446222961742
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    176000  -10442.751     -10442.751     -10519.085     -10519.085      295.42033      295.42033      28026.379      28026.379      865.76772      865.76772    
    177000  -10446.328     -10446.328     -10521.145     -10521.145      289.54834      289.54834      28047.565      28047.565     -373.75949     -373.75949    
Loop time of 105.311 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.253 hours/ns, 9.496 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    | 104.77     | 104.77     | 104.77     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081421   | 0.081421   | 0.081421   |   0.0 |  0.08
Output  | 0.00016599 | 0.00016599 | 0.00016599 |   0.0 |  0.00
Modify  | 0.39684    | 0.39684    | 0.39684    |   0.0 |  0.38
Other   |            | 0.05921    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3131 ave        3131 max        3131 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119066 ave      119066 max      119066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119066
Ave neighs/atom = 59.533
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.845239828692, Press = 0.29047625479875
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    177000  -10446.328     -10446.328     -10521.145     -10521.145      289.54834      289.54834      28047.565      28047.565     -373.75949     -373.75949    
    178000  -10443.317     -10443.317     -10518.485     -10518.485      290.91112      290.91112      28043.401      28043.401      67.060126      67.060126    
Loop time of 104.62 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.061 hours/ns, 9.558 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.09     | 104.09     | 104.09     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080614   | 0.080614   | 0.080614   |   0.0 |  0.08
Output  | 0.00021082 | 0.00021082 | 0.00021082 |   0.0 |  0.00
Modify  | 0.39473    | 0.39473    | 0.39473    |   0.0 |  0.38
Other   |            | 0.05912    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3095 ave        3095 max        3095 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118842 ave      118842 max      118842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118842
Ave neighs/atom = 59.421
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.853536373876, Press = 0.18924788724237
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    178000  -10443.317     -10443.317     -10518.485     -10518.485      290.91112      290.91112      28043.401      28043.401      67.060126      67.060126    
    179000  -10445.326     -10445.326     -10521.506     -10521.506      294.82418      294.82418      28010.072      28010.072      1537.242       1537.242     
Loop time of 103.958 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.877 hours/ns, 9.619 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    | 103.43     | 103.43     | 103.43     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080963   | 0.080963   | 0.080963   |   0.0 |  0.08
Output  | 0.00016371 | 0.00016371 | 0.00016371 |   0.0 |  0.00
Modify  | 0.39098    | 0.39098    | 0.39098    |   0.0 |  0.38
Other   |            | 0.05856    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3133 ave        3133 max        3133 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118932 ave      118932 max      118932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118932
Ave neighs/atom = 59.466
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.853606283023, Press = 0.260661767633739
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    179000  -10445.326     -10445.326     -10521.506     -10521.506      294.82418      294.82418      28010.072      28010.072      1537.242       1537.242     
    180000  -10440.733     -10440.733     -10517.437     -10517.437      296.85478      296.85478      28062.44       28062.44      -870.73416     -870.73416    
Loop time of 106.104 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.473 hours/ns, 9.425 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    | 105.56     | 105.56     | 105.56     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082771   | 0.082771   | 0.082771   |   0.0 |  0.08
Output  | 0.00016457 | 0.00016457 | 0.00016457 |   0.0 |  0.00
Modify  | 0.40067    | 0.40067    | 0.40067    |   0.0 |  0.38
Other   |            | 0.05932    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3154 ave        3154 max        3154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119008 ave      119008 max      119008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119008
Ave neighs/atom = 59.504
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.867230774855, Press = 0.575256103329822
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    180000  -10440.733     -10440.733     -10517.437     -10517.437      296.85478      296.85478      28062.44       28062.44      -870.73416     -870.73416    
    181000  -10443.983     -10443.983     -10518.256     -10518.256      287.44718      287.44718      28078.252      28078.252     -1911.7013     -1911.7013    
Loop time of 105.673 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.354 hours/ns, 9.463 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.13     | 105.13     | 105.13     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082093   | 0.082093   | 0.082093   |   0.0 |  0.08
Output  | 0.00016392 | 0.00016392 | 0.00016392 |   0.0 |  0.00
Modify  | 0.39875    | 0.39875    | 0.39875    |   0.0 |  0.38
Other   |            | 0.05921    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3122 ave        3122 max        3122 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118942 ave      118942 max      118942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118942
Ave neighs/atom = 59.471
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.866983049244, Press = -0.0892328424369212
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    181000  -10443.983     -10443.983     -10518.256     -10518.256      287.44718      287.44718      28078.252      28078.252     -1911.7013     -1911.7013    
    182000  -10444.265     -10444.265     -10522.01      -10522.01       300.88158      300.88158      28001.279      28001.279      2026.1709      2026.1709    
Loop time of 103.779 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.828 hours/ns, 9.636 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    | 103.25     | 103.25     | 103.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082148   | 0.082148   | 0.082148   |   0.0 |  0.08
Output  | 0.00019644 | 0.00019644 | 0.00019644 |   0.0 |  0.00
Modify  | 0.3924     | 0.3924     | 0.3924     |   0.0 |  0.38
Other   |            | 0.0583     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3138 ave        3138 max        3138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118906 ave      118906 max      118906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118906
Ave neighs/atom = 59.453
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.861677365757, Press = 0.193581235776166
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    182000  -10444.265     -10444.265     -10522.01      -10522.01       300.88158      300.88158      28001.279      28001.279      2026.1709      2026.1709    
    183000  -10445.837     -10445.837     -10521.021     -10521.021      290.97124      290.97124      28038.193      28038.193     -55.300461     -55.300461    
Loop time of 103.686 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.802 hours/ns, 9.644 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    | 103.16     | 103.16     | 103.16     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08124    | 0.08124    | 0.08124    |   0.0 |  0.08
Output  | 0.00016395 | 0.00016395 | 0.00016395 |   0.0 |  0.00
Modify  | 0.38903    | 0.38903    | 0.38903    |   0.0 |  0.38
Other   |            | 0.05849    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3139 ave        3139 max        3139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118978 ave      118978 max      118978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118978
Ave neighs/atom = 59.489
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.848842649914, Press = 0.424043347359415
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    183000  -10445.837     -10445.837     -10521.021     -10521.021      290.97124      290.97124      28038.193      28038.193     -55.300461     -55.300461    
    184000  -10444.193     -10444.193     -10521.339     -10521.339      298.56263      298.56263      28056.942      28056.942     -1018.6456     -1018.6456    
Loop time of 106.384 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.551 hours/ns, 9.400 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.84     | 105.84     | 105.84     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082352   | 0.082352   | 0.082352   |   0.0 |  0.08
Output  | 0.00020976 | 0.00020976 | 0.00020976 |   0.0 |  0.00
Modify  | 0.40546    | 0.40546    | 0.40546    |   0.0 |  0.38
Other   |            | 0.05926    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3134 ave        3134 max        3134 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119010 ave      119010 max      119010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119010
Ave neighs/atom = 59.505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.848190846937, Press = 0.220517961705004
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    184000  -10444.193     -10444.193     -10521.339     -10521.339      298.56263      298.56263      28056.942      28056.942     -1018.6456     -1018.6456    
    185000  -10445.428     -10445.428     -10521.028     -10521.028      292.57822      292.57822      28025.077      28025.077      741.30485      741.30485    
Loop time of 104.998 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.166 hours/ns, 9.524 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    | 104.46     | 104.46     | 104.46     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081551   | 0.081551   | 0.081551   |   0.0 |  0.08
Output  | 0.00016226 | 0.00016226 | 0.00016226 |   0.0 |  0.00
Modify  | 0.39512    | 0.39512    | 0.39512    |   0.0 |  0.38
Other   |            | 0.05915    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3116 ave        3116 max        3116 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118896 ave      118896 max      118896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118896
Ave neighs/atom = 59.448
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.837207689862, Press = 0.154912257773381
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    185000  -10445.428     -10445.428     -10521.028     -10521.028      292.57822      292.57822      28025.077      28025.077      741.30485      741.30485    
    186000  -10444.976     -10444.976     -10518.659     -10518.659      285.15943      285.15943      28032.883      28032.883      571.80316      571.80316    
Loop time of 105.316 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.254 hours/ns, 9.495 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    | 104.77     | 104.77     | 104.77     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081667   | 0.081667   | 0.081667   |   0.0 |  0.08
Output  | 0.00019927 | 0.00019927 | 0.00019927 |   0.0 |  0.00
Modify  | 0.39975    | 0.39975    | 0.39975    |   0.0 |  0.38
Other   |            | 0.05911    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3107 ave        3107 max        3107 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118948 ave      118948 max      118948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118948
Ave neighs/atom = 59.474
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.829820793788, Press = 0.808646960783562
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    186000  -10444.976     -10444.976     -10518.659     -10518.659      285.15943      285.15943      28032.883      28032.883      571.80316      571.80316    
    187000  -10443.891     -10443.891     -10518.393     -10518.393      288.33327      288.33327      28094.617      28094.617     -2733.2379     -2733.2379    
Loop time of 102.551 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.843 ns/day, 28.486 hours/ns, 9.751 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    | 102.03     | 102.03     | 102.03     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080416   | 0.080416   | 0.080416   |   0.0 |  0.08
Output  | 0.00020955 | 0.00020955 | 0.00020955 |   0.0 |  0.00
Modify  | 0.38396    | 0.38396    | 0.38396    |   0.0 |  0.37
Other   |            | 0.0578     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3136 ave        3136 max        3136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119016 ave      119016 max      119016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119016
Ave neighs/atom = 59.508
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.828232813898, Press = 0.0507923364362221
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    187000  -10443.891     -10443.891     -10518.393     -10518.393      288.33327      288.33327      28094.617      28094.617     -2733.2379     -2733.2379    
    188000  -10449.534     -10449.534     -10522.329     -10522.329      281.72618      281.72618      28004.903      28004.903      1767.841       1767.841     
Loop time of 105.949 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.430 hours/ns, 9.439 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    | 105.41     | 105.41     | 105.41     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081784   | 0.081784   | 0.081784   |   0.0 |  0.08
Output  | 0.00016971 | 0.00016971 | 0.00016971 |   0.0 |  0.00
Modify  | 0.40155    | 0.40155    | 0.40155    |   0.0 |  0.38
Other   |            | 0.0594     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3092 ave        3092 max        3092 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118778 ave      118778 max      118778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118778
Ave neighs/atom = 59.389
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.822809932738, Press = 0.197816183982338
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    188000  -10449.534     -10449.534     -10522.329     -10522.329      281.72618      281.72618      28004.903      28004.903      1767.841       1767.841     
    189000  -10443.176     -10443.176     -10519.987     -10519.987      297.26625      297.26625      28051.072      28051.072     -437.04814     -437.04814    
Loop time of 105.341 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.261 hours/ns, 9.493 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    | 104.8      | 104.8      | 104.8      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081149   | 0.081149   | 0.081149   |   0.0 |  0.08
Output  | 0.00020461 | 0.00020461 | 0.00020461 |   0.0 |  0.00
Modify  | 0.39708    | 0.39708    | 0.39708    |   0.0 |  0.38
Other   |            | 0.05889    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3111 ave        3111 max        3111 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118992 ave      118992 max      118992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118992
Ave neighs/atom = 59.496
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.816015578343, Press = 0.397365273456052
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    189000  -10443.176     -10443.176     -10519.987     -10519.987      297.26625      297.26625      28051.072      28051.072     -437.04814     -437.04814    
    190000  -10446.432     -10446.432     -10520.482     -10520.482      286.58075      286.58075      28047.392      28047.392     -441.06937     -441.06937    
Loop time of 108.344 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.797 ns/day, 30.096 hours/ns, 9.230 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    | 107.79     | 107.79     | 107.79     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083126   | 0.083126   | 0.083126   |   0.0 |  0.08
Output  | 0.00016342 | 0.00016342 | 0.00016342 |   0.0 |  0.00
Modify  | 0.41023    | 0.41023    | 0.41023    |   0.0 |  0.38
Other   |            | 0.06052    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3104 ave        3104 max        3104 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119016 ave      119016 max      119016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119016
Ave neighs/atom = 59.508
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.807184336348, Press = 0.0567579477752463
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    190000  -10446.432     -10446.432     -10520.482     -10520.482      286.58075      286.58075      28047.392      28047.392     -441.06937     -441.06937    
    191000  -10442.883     -10442.883     -10519.768     -10519.768      297.55247      297.55247      27987.014      27987.014      3006.9716      3006.9716    
Loop time of 107.127 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.807 ns/day, 29.758 hours/ns, 9.335 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    | 106.58     | 106.58     | 106.58     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083349   | 0.083349   | 0.083349   |   0.0 |  0.08
Output  | 0.00023015 | 0.00023015 | 0.00023015 |   0.0 |  0.00
Modify  | 0.4088     | 0.4088     | 0.4088     |   0.0 |  0.38
Other   |            | 0.05962    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3140 ave        3140 max        3140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118930 ave      118930 max      118930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118930
Ave neighs/atom = 59.465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.796664749877, Press = 0.407224040915332
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    191000  -10442.883     -10442.883     -10519.768     -10519.768      297.55247      297.55247      27987.014      27987.014      3006.9716      3006.9716    
    192000  -10446.271     -10446.271     -10521.481     -10521.481      291.06884      291.06884      28094.118      28094.118     -2957.2269     -2957.2269    
Loop time of 104.754 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.098 hours/ns, 9.546 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.22     | 104.22     | 104.22     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08135    | 0.08135    | 0.08135    |   0.0 |  0.08
Output  | 0.0001648  | 0.0001648  | 0.0001648  |   0.0 |  0.00
Modify  | 0.39254    | 0.39254    | 0.39254    |   0.0 |  0.37
Other   |            | 0.05885    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3138 ave        3138 max        3138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119146 ave      119146 max      119146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119146
Ave neighs/atom = 59.573
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.796526774906, Press = 0.602497254842377
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    192000  -10446.271     -10446.271     -10521.481     -10521.481      291.06884      291.06884      28094.118      28094.118     -2957.2269     -2957.2269    
    193000  -10443.586     -10443.586     -10521.187     -10521.187      300.32298      300.32298      28054.698      28054.698     -704.64753     -704.64753    
Loop time of 105.264 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.240 hours/ns, 9.500 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.72     | 104.72     | 104.72     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081777   | 0.081777   | 0.081777   |   0.0 |  0.08
Output  | 0.00020632 | 0.00020632 | 0.00020632 |   0.0 |  0.00
Modify  | 0.39993    | 0.39993    | 0.39993    |   0.0 |  0.38
Other   |            | 0.05894    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3119 ave        3119 max        3119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118730 ave      118730 max      118730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118730
Ave neighs/atom = 59.365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.80912754665, Press = 0.00153368893917567
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    193000  -10443.586     -10443.586     -10521.187     -10521.187      300.32298      300.32298      28054.698      28054.698     -704.64753     -704.64753    
    194000  -10444.421     -10444.421     -10520.419     -10520.419      294.12006      294.12006      28008.963      28008.963      1769.2219      1769.2219    
Loop time of 104.135 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.926 hours/ns, 9.603 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    | 103.61     | 103.61     | 103.61     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081302   | 0.081302   | 0.081302   |   0.0 |  0.08
Output  | 0.0001647  | 0.0001647  | 0.0001647  |   0.0 |  0.00
Modify  | 0.38932    | 0.38932    | 0.38932    |   0.0 |  0.37
Other   |            | 0.05819    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3112 ave        3112 max        3112 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118926 ave      118926 max      118926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118926
Ave neighs/atom = 59.463
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.819482193326, Press = 0.316196575235529
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    194000  -10444.421     -10444.421     -10520.419     -10520.419      294.12006      294.12006      28008.963      28008.963      1769.2219      1769.2219    
    195000  -10445.501     -10445.501     -10522.75      -10522.75       298.96272      298.96272      28062.149      28062.149     -1355.0236     -1355.0236    
Loop time of 106.179 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.494 hours/ns, 9.418 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    | 105.63     | 105.63     | 105.63     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083331   | 0.083331   | 0.083331   |   0.0 |  0.08
Output  | 0.00016429 | 0.00016429 | 0.00016429 |   0.0 |  0.00
Modify  | 0.40412    | 0.40412    | 0.40412    |   0.0 |  0.38
Other   |            | 0.05982    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3139 ave        3139 max        3139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118932 ave      118932 max      118932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118932
Ave neighs/atom = 59.466
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.822487139244, Press = 0.429632459431205
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    195000  -10445.501     -10445.501     -10522.75      -10522.75       298.96272      298.96272      28062.149      28062.149     -1355.0236     -1355.0236    
    196000  -10445.685     -10445.685     -10522.466     -10522.466      297.15134      297.15134      28055.448      28055.448     -922.13086     -922.13086    
Loop time of 105.953 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.431 hours/ns, 9.438 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    | 105.41     | 105.41     | 105.41     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082267   | 0.082267   | 0.082267   |   0.0 |  0.08
Output  | 0.00016462 | 0.00016462 | 0.00016462 |   0.0 |  0.00
Modify  | 0.40256    | 0.40256    | 0.40256    |   0.0 |  0.38
Other   |            | 0.0595     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3141 ave        3141 max        3141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118826 ave      118826 max      118826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118826
Ave neighs/atom = 59.413
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.812549704325, Press = 0.0477502688118013
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    196000  -10445.685     -10445.685     -10522.466     -10522.466      297.15134      297.15134      28055.448      28055.448     -922.13086     -922.13086    
    197000  -10443.31      -10443.31      -10518.813     -10518.813      292.20595      292.20595      27967.696      27967.696      4292.6119      4292.6119    
Loop time of 106.391 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.553 hours/ns, 9.399 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    | 105.84     | 105.84     | 105.84     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082657   | 0.082657   | 0.082657   |   0.0 |  0.08
Output  | 0.00016422 | 0.00016422 | 0.00016422 |   0.0 |  0.00
Modify  | 0.40593    | 0.40593    | 0.40593    |   0.0 |  0.38
Other   |            | 0.05945    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3135 ave        3135 max        3135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118906 ave      118906 max      118906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118906
Ave neighs/atom = 59.453
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.814690808146, Press = 0.368105115236391
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    197000  -10443.31      -10443.31      -10518.813     -10518.813      292.20595      292.20595      27967.696      27967.696      4292.6119      4292.6119    
    198000  -10446.11      -10446.11      -10521.829     -10521.829      293.03806      293.03806      28069.615      28069.615     -1664.626      -1664.626     
Loop time of 106.137 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.483 hours/ns, 9.422 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    | 105.6      | 105.6      | 105.6      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081965   | 0.081965   | 0.081965   |   0.0 |  0.08
Output  | 0.00026524 | 0.00026524 | 0.00026524 |   0.0 |  0.00
Modify  | 0.40062    | 0.40062    | 0.40062    |   0.0 |  0.38
Other   |            | 0.05917    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3130 ave        3130 max        3130 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119200 ave      119200 max      119200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119200
Ave neighs/atom = 59.6
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.81985738056, Press = 0.597617471643205
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    198000  -10446.11      -10446.11      -10521.829     -10521.829      293.03806      293.03806      28069.615      28069.615     -1664.626      -1664.626     
    199000  -10442.465     -10442.465     -10519.502     -10519.502      298.14074      298.14074      28061.794      28061.794     -929.66611     -929.66611    
Loop time of 105.314 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.254 hours/ns, 9.495 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    | 104.78     | 104.78     | 104.78     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081556   | 0.081556   | 0.081556   |   0.0 |  0.08
Output  | 0.00019715 | 0.00019715 | 0.00019715 |   0.0 |  0.00
Modify  | 0.39541    | 0.39541    | 0.39541    |   0.0 |  0.38
Other   |            | 0.0592     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3116 ave        3116 max        3116 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118808 ave      118808 max      118808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118808
Ave neighs/atom = 59.404
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.819647004668, Press = 0.0509219850703425
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    199000  -10442.465     -10442.465     -10519.502     -10519.502      298.14074      298.14074      28061.794      28061.794     -929.66611     -929.66611    
    200000  -10447.333     -10447.333     -10522.825     -10522.825      292.16387      292.16387      28011.791      28011.791      1470.3641      1470.3641    
Loop time of 106.927 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.702 hours/ns, 9.352 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    | 106.38     | 106.38     | 106.38     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082382   | 0.082382   | 0.082382   |   0.0 |  0.08
Output  | 0.00016518 | 0.00016518 | 0.00016518 |   0.0 |  0.00
Modify  | 0.40373    | 0.40373    | 0.40373    |   0.0 |  0.38
Other   |            | 0.06002    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3121 ave        3121 max        3121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118850 ave      118850 max      118850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118850
Ave neighs/atom = 59.425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.81175274132, Press = 0.309602790577181
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    200000  -10447.333     -10447.333     -10522.825     -10522.825      292.16387      292.16387      28011.791      28011.791      1470.3641      1470.3641    
    201000  -10444.082     -10444.082     -10519.818     -10519.818      293.1094       293.1094       28056.01       28056.01      -648.10115     -648.10115    
Loop time of 105.497 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.305 hours/ns, 9.479 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.96     | 104.96     | 104.96     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081418   | 0.081418   | 0.081418   |   0.0 |  0.08
Output  | 0.00020769 | 0.00020769 | 0.00020769 |   0.0 |  0.00
Modify  | 0.39778    | 0.39778    | 0.39778    |   0.0 |  0.38
Other   |            | 0.05983    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3116 ave        3116 max        3116 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118850 ave      118850 max      118850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118850
Ave neighs/atom = 59.425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.804509257941, Press = 0.422972842339551
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    201000  -10444.082     -10444.082     -10519.818     -10519.818      293.1094       293.1094       28056.01       28056.01      -648.10115     -648.10115    
    202000  -10446.953     -10446.953     -10522.61      -10522.61       292.80167      292.80167      28063.375      28063.375     -1281.8137     -1281.8137    
Loop time of 103.364 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.712 hours/ns, 9.675 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    | 102.83     | 102.83     | 102.83     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081642   | 0.081642   | 0.081642   |   0.0 |  0.08
Output  | 0.00016412 | 0.00016412 | 0.00016412 |   0.0 |  0.00
Modify  | 0.38908    | 0.38908    | 0.38908    |   0.0 |  0.38
Other   |            | 0.05858    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3140 ave        3140 max        3140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118926 ave      118926 max      118926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118926
Ave neighs/atom = 59.463
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.801779236123, Press = -0.100420669251067
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    202000  -10446.953     -10446.953     -10522.61      -10522.61       292.80167      292.80167      28063.375      28063.375     -1281.8137     -1281.8137    
    203000  -10443.863     -10443.863     -10521.586     -10521.586      300.79601      300.79601      27976.556      27976.556      3490.9655      3490.9655    
Loop time of 105.173 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.215 hours/ns, 9.508 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    | 104.64     | 104.64     | 104.64     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082276   | 0.082276   | 0.082276   |   0.0 |  0.08
Output  | 0.00016499 | 0.00016499 | 0.00016499 |   0.0 |  0.00
Modify  | 0.39592    | 0.39592    | 0.39592    |   0.0 |  0.38
Other   |            | 0.05927    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3142 ave        3142 max        3142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118804 ave      118804 max      118804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118804
Ave neighs/atom = 59.402
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.803901495551, Press = 0.350943894065938
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    203000  -10443.863     -10443.863     -10521.586     -10521.586      300.79601      300.79601      27976.556      27976.556      3490.9655      3490.9655    
    204000  -10448.293     -10448.293     -10521.918     -10521.918      284.93381      284.93381      28063.732      28063.732     -1474.7612     -1474.7612    
Loop time of 104.957 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.155 hours/ns, 9.528 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.42     | 104.42     | 104.42     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081841   | 0.081841   | 0.081841   |   0.0 |  0.08
Output  | 0.00047453 | 0.00047453 | 0.00047453 |   0.0 |  0.00
Modify  | 0.39561    | 0.39561    | 0.39561    |   0.0 |  0.38
Other   |            | 0.05908    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3165 ave        3165 max        3165 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119064 ave      119064 max      119064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119064
Ave neighs/atom = 59.532
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.800141829132, Press = 0.51098327039732
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    204000  -10448.293     -10448.293     -10521.918     -10521.918      284.93381      284.93381      28063.732      28063.732     -1474.7612     -1474.7612    
    205000  -10443.611     -10443.611     -10519.074     -10519.074      292.05112      292.05112      28050.151      28050.151     -360.91433     -360.91433    
Loop time of 106.091 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.470 hours/ns, 9.426 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    | 105.54     | 105.54     | 105.54     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083161   | 0.083161   | 0.083161   |   0.0 |  0.08
Output  | 0.00016399 | 0.00016399 | 0.00016399 |   0.0 |  0.00
Modify  | 0.40227    | 0.40227    | 0.40227    |   0.0 |  0.38
Other   |            | 0.06011    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3173 ave        3173 max        3173 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118948 ave      118948 max      118948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118948
Ave neighs/atom = 59.474
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.785206862899, Press = 0.0807903419050824
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    205000  -10443.611     -10443.611     -10519.074     -10519.074      292.05112      292.05112      28050.151      28050.151     -360.91433     -360.91433    
    206000  -10445.542     -10445.542     -10521.68      -10521.68       294.66545      294.66545      28008.413      28008.413      1550.8646      1550.8646    
Loop time of 104.036 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.899 hours/ns, 9.612 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    | 103.5      | 103.5      | 103.5      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081335   | 0.081335   | 0.081335   |   0.0 |  0.08
Output  | 0.00016544 | 0.00016544 | 0.00016544 |   0.0 |  0.00
Modify  | 0.39187    | 0.39187    | 0.39187    |   0.0 |  0.38
Other   |            | 0.05859    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3153 ave        3153 max        3153 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118908 ave      118908 max      118908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118908
Ave neighs/atom = 59.454
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.792611429198, Press = 0.364507084522253
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    206000  -10445.542     -10445.542     -10521.68      -10521.68       294.66545      294.66545      28008.413      28008.413      1550.8646      1550.8646    
    207000  -10444.548     -10444.548     -10521.01      -10521.01       295.91846      295.91846      28067.953      28067.953     -1475.678      -1475.678     
Loop time of 103.441 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.835 ns/day, 28.734 hours/ns, 9.667 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.91     | 102.91     | 102.91     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081825   | 0.081825   | 0.081825   |   0.0 |  0.08
Output  | 0.00016476 | 0.00016476 | 0.00016476 |   0.0 |  0.00
Modify  | 0.38642    | 0.38642    | 0.38642    |   0.0 |  0.37
Other   |            | 0.05865    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3158 ave        3158 max        3158 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119038 ave      119038 max      119038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119038
Ave neighs/atom = 59.519
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.801050665135, Press = 0.471039829706571
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    207000  -10444.548     -10444.548     -10521.01      -10521.01       295.91846      295.91846      28067.953      28067.953     -1475.678      -1475.678     
    208000  -10445.617     -10445.617     -10519.475     -10519.475      285.83866      285.83866      28052.437      28052.437     -638.24752     -638.24752    
Loop time of 104.853 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.126 hours/ns, 9.537 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    | 104.31     | 104.31     | 104.31     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081702   | 0.081702   | 0.081702   |   0.0 |  0.08
Output  | 0.00016361 | 0.00016361 | 0.00016361 |   0.0 |  0.00
Modify  | 0.39897    | 0.39897    | 0.39897    |   0.0 |  0.38
Other   |            | 0.05977    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3109 ave        3109 max        3109 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118850 ave      118850 max      118850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118850
Ave neighs/atom = 59.425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.804054329901, Press = -0.215403559652395
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    208000  -10445.617     -10445.617     -10519.475     -10519.475      285.83866      285.83866      28052.437      28052.437     -638.24752     -638.24752    
    209000  -10443.735     -10443.735     -10521.66      -10521.66       301.57857      301.57857      28002.691      28002.691      1900.2171      1900.2171    
Loop time of 104.27 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.964 hours/ns, 9.590 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    | 103.74     | 103.74     | 103.74     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080918   | 0.080918   | 0.080918   |   0.0 |  0.08
Output  | 0.0001667  | 0.0001667  | 0.0001667  |   0.0 |  0.00
Modify  | 0.39201    | 0.39201    | 0.39201    |   0.0 |  0.38
Other   |            | 0.0583     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3128 ave        3128 max        3128 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118942 ave      118942 max      118942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118942
Ave neighs/atom = 59.471
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.800774055982, Press = 0.449573862925393
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    209000  -10443.735     -10443.735     -10521.66      -10521.66       301.57857      301.57857      28002.691      28002.691      1900.2171      1900.2171    
    210000  -10444.037     -10444.037     -10518.197     -10518.197      287.00941      287.00941      28057.71       28057.71      -635.97951     -635.97951    
Loop time of 104.531 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.036 hours/ns, 9.567 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    | 104        | 104        | 104        |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081749   | 0.081749   | 0.081749   |   0.0 |  0.08
Output  | 0.00020843 | 0.00020843 | 0.00020843 |   0.0 |  0.00
Modify  | 0.39478    | 0.39478    | 0.39478    |   0.0 |  0.38
Other   |            | 0.05865    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3151 ave        3151 max        3151 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119058 ave      119058 max      119058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119058
Ave neighs/atom = 59.529
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.80197687325, Press = 0.388000692605941
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    210000  -10444.037     -10444.037     -10518.197     -10518.197      287.00941      287.00941      28057.71       28057.71      -635.97951     -635.97951    
    211000  -10441.595     -10441.595     -10517.399     -10517.399      293.3684       293.3684       28054.708      28054.708     -526.62971     -526.62971    
Loop time of 102.835 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.840 ns/day, 28.565 hours/ns, 9.724 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    | 102.31     | 102.31     | 102.31     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079882   | 0.079882   | 0.079882   |   0.0 |  0.08
Output  | 0.00025201 | 0.00025201 | 0.00025201 |   0.0 |  0.00
Modify  | 0.38364    | 0.38364    | 0.38364    |   0.0 |  0.37
Other   |            | 0.0582     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3127 ave        3127 max        3127 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118974 ave      118974 max      118974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118974
Ave neighs/atom = 59.487
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.797751118007, Press = 0.195058305170199
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    211000  -10441.595     -10441.595     -10517.399     -10517.399      293.3684       293.3684       28054.708      28054.708     -526.62971     -526.62971    
    212000  -10445.598     -10445.598     -10519.291     -10519.291      285.1975       285.1975       28017.185      28017.185      1291.1893      1291.1893    
Loop time of 103.827 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.841 hours/ns, 9.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    | 103.3      | 103.3      | 103.3      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080954   | 0.080954   | 0.080954   |   0.0 |  0.08
Output  | 0.00020603 | 0.00020603 | 0.00020603 |   0.0 |  0.00
Modify  | 0.39154    | 0.39154    | 0.39154    |   0.0 |  0.38
Other   |            | 0.0589     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3127 ave        3127 max        3127 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118912 ave      118912 max      118912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118912
Ave neighs/atom = 59.456
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.807022116845, Press = 0.387070065421966
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    212000  -10445.598     -10445.598     -10519.291     -10519.291      285.1975       285.1975       28017.185      28017.185      1291.1893      1291.1893    
    213000  -10444.493     -10444.493     -10521.467     -10521.467      297.89728      297.89728      28078.143      28078.143     -2070.3855     -2070.3855    
Loop time of 105.74 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.372 hours/ns, 9.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    | 105.2      | 105.2      | 105.2      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083314   | 0.083314   | 0.083314   |   0.0 |  0.08
Output  | 0.00016375 | 0.00016375 | 0.00016375 |   0.0 |  0.00
Modify  | 0.40062    | 0.40062    | 0.40062    |   0.0 |  0.38
Other   |            | 0.0595     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3203 ave        3203 max        3203 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118962 ave      118962 max      118962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118962
Ave neighs/atom = 59.481
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.812875432041, Press = 0.429072536433127
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    213000  -10444.493     -10444.493     -10521.467     -10521.467      297.89728      297.89728      28078.143      28078.143     -2070.3855     -2070.3855    
    214000  -10443.235     -10443.235     -10519.83      -10519.83       296.43071      296.43071      28048.627      28048.627     -441.38408     -441.38408    
Loop time of 105.958 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.433 hours/ns, 9.438 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    | 105.42     | 105.42     | 105.42     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082583   | 0.082583   | 0.082583   |   0.0 |  0.08
Output  | 0.00016384 | 0.00016384 | 0.00016384 |   0.0 |  0.00
Modify  | 0.39635    | 0.39635    | 0.39635    |   0.0 |  0.37
Other   |            | 0.05941    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3159 ave        3159 max        3159 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118782 ave      118782 max      118782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118782
Ave neighs/atom = 59.391
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.803275577836, Press = -0.020697210598798
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    214000  -10443.235     -10443.235     -10519.83      -10519.83       296.43071      296.43071      28048.627      28048.627     -441.38408     -441.38408    
    215000  -10447.407     -10447.407     -10523.833     -10523.833      295.77917      295.77917      27999.855      27999.855      1857.8899      1857.8899    
Loop time of 103.381 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.717 hours/ns, 9.673 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.85     | 102.85     | 102.85     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080369   | 0.080369   | 0.080369   |   0.0 |  0.08
Output  | 0.00016411 | 0.00016411 | 0.00016411 |   0.0 |  0.00
Modify  | 0.38829    | 0.38829    | 0.38829    |   0.0 |  0.38
Other   |            | 0.05838    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3145 ave        3145 max        3145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118870 ave      118870 max      118870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118870
Ave neighs/atom = 59.435
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.800441205635, Press = 0.438323478652978
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    215000  -10447.407     -10447.407     -10523.833     -10523.833      295.77917      295.77917      27999.855      27999.855      1857.8899      1857.8899    
    216000  -10444.295     -10444.295     -10517.911     -10517.911      284.89902      284.89902      28071.529      28071.529     -1489.2691     -1489.2691    
Loop time of 103.557 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.766 hours/ns, 9.657 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    | 103.03     | 103.03     | 103.03     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079942   | 0.079942   | 0.079942   |   0.0 |  0.08
Output  | 0.00016155 | 0.00016155 | 0.00016155 |   0.0 |  0.00
Modify  | 0.38771    | 0.38771    | 0.38771    |   0.0 |  0.37
Other   |            | 0.05808    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3121 ave        3121 max        3121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118988 ave      118988 max      118988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118988
Ave neighs/atom = 59.494
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.801239577343, Press = 0.38711087346572
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    216000  -10444.295     -10444.295     -10517.911     -10517.911      284.89902      284.89902      28071.529      28071.529     -1489.2691     -1489.2691    
    217000  -10446.548     -10446.548     -10520.682     -10520.682      286.90655      286.90655      28037.969      28037.969      86.746032      86.746032    
Loop time of 106.112 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.476 hours/ns, 9.424 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    | 105.57     | 105.57     | 105.57     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082052   | 0.082052   | 0.082052   |   0.0 |  0.08
Output  | 0.0001976  | 0.0001976  | 0.0001976  |   0.0 |  0.00
Modify  | 0.40092    | 0.40092    | 0.40092    |   0.0 |  0.38
Other   |            | 0.05999    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3106 ave        3106 max        3106 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118886 ave      118886 max      118886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118886
Ave neighs/atom = 59.443
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.802736407675, Press = 0.13898536605041
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    217000  -10446.548     -10446.548     -10520.682     -10520.682      286.90655      286.90655      28037.969      28037.969      86.746032      86.746032    
    218000  -10443.898     -10443.898     -10519.621     -10519.621      293.05803      293.05803      28031.945      28031.945      609.22473      609.22473    
Loop time of 104.69 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.080 hours/ns, 9.552 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    | 104.16     | 104.16     | 104.16     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079607   | 0.079607   | 0.079607   |   0.0 |  0.08
Output  | 0.00016261 | 0.00016261 | 0.00016261 |   0.0 |  0.00
Modify  | 0.39447    | 0.39447    | 0.39447    |   0.0 |  0.38
Other   |            | 0.05866    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3083 ave        3083 max        3083 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118946 ave      118946 max      118946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118946
Ave neighs/atom = 59.473
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.798835666603, Press = 0.333232587913161
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    218000  -10443.898     -10443.898     -10519.621     -10519.621      293.05803      293.05803      28031.945      28031.945      609.22473      609.22473    
    219000  -10449.28      -10449.28      -10521.946     -10521.946      281.22554      281.22554      28040.675      28040.675     -331.12452     -331.12452    
Loop time of 104.02 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.894 hours/ns, 9.614 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.49     | 103.49     | 103.49     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080717   | 0.080717   | 0.080717   |   0.0 |  0.08
Output  | 0.00016392 | 0.00016392 | 0.00016392 |   0.0 |  0.00
Modify  | 0.3914     | 0.3914     | 0.3914     |   0.0 |  0.38
Other   |            | 0.05847    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3127 ave        3127 max        3127 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118930 ave      118930 max      118930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118930
Ave neighs/atom = 59.465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.789002920684, Press = 0.272296696963624
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    219000  -10449.28      -10449.28      -10521.946     -10521.946      281.22554      281.22554      28040.675      28040.675     -331.12452     -331.12452    
    220000  -10444.386     -10444.386     -10520.372     -10520.372      294.07371      294.07371      28032.024      28032.024      455.18296      455.18296    
Loop time of 104.713 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.087 hours/ns, 9.550 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.18     | 104.18     | 104.18     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08074    | 0.08074    | 0.08074    |   0.0 |  0.08
Output  | 0.00016293 | 0.00016293 | 0.00016293 |   0.0 |  0.00
Modify  | 0.39646    | 0.39646    | 0.39646    |   0.0 |  0.38
Other   |            | 0.05946    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3102 ave        3102 max        3102 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118888 ave      118888 max      118888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118888
Ave neighs/atom = 59.444
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.784587737584, Press = 0.248443311985018
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    220000  -10444.386     -10444.386     -10520.372     -10520.372      294.07371      294.07371      28032.024      28032.024      455.18296      455.18296    
    221000  -10445.08      -10445.08      -10519.724     -10519.724      288.87695      288.87695      28032.472      28032.472      512.5351       512.5351     
Loop time of 105.094 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.193 hours/ns, 9.515 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    | 104.56     | 104.56     | 104.56     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08134    | 0.08134    | 0.08134    |   0.0 |  0.08
Output  | 0.00016448 | 0.00016448 | 0.00016448 |   0.0 |  0.00
Modify  | 0.39316    | 0.39316    | 0.39316    |   0.0 |  0.37
Other   |            | 0.05887    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3129 ave        3129 max        3129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118954 ave      118954 max      118954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118954
Ave neighs/atom = 59.477
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.787730217231, Press = 0.403460240414254
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    221000  -10445.08      -10445.08      -10519.724     -10519.724      288.87695      288.87695      28032.472      28032.472      512.5351       512.5351     
    222000  -10443.836     -10443.836     -10520.988     -10520.988      298.5859       298.5859       28091.751      28091.751     -2763.03       -2763.03      
Loop time of 105.312 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.253 hours/ns, 9.496 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    | 104.77     | 104.77     | 104.77     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081304   | 0.081304   | 0.081304   |   0.0 |  0.08
Output  | 0.00016738 | 0.00016738 | 0.00016738 |   0.0 |  0.00
Modify  | 0.39715    | 0.39715    | 0.39715    |   0.0 |  0.38
Other   |            | 0.05949    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3117 ave        3117 max        3117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118950 ave      118950 max      118950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118950
Ave neighs/atom = 59.475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.788113397483, Press = 0.173830954392755
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    222000  -10443.836     -10443.836     -10520.988     -10520.988      298.5859       298.5859       28091.751      28091.751     -2763.03       -2763.03      
    223000  -10446.557     -10446.557     -10521.768     -10521.768      291.07382      291.07382      28009.99       28009.99       1512.6986      1512.6986    
Loop time of 104.432 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.009 hours/ns, 9.576 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.9      | 103.9      | 103.9      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081335   | 0.081335   | 0.081335   |   0.0 |  0.08
Output  | 0.00026232 | 0.00026232 | 0.00026232 |   0.0 |  0.00
Modify  | 0.39613    | 0.39613    | 0.39613    |   0.0 |  0.38
Other   |            | 0.05915    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3117 ave        3117 max        3117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118716 ave      118716 max      118716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118716
Ave neighs/atom = 59.358
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.782314583321, Press = -0.0477088469315137
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    223000  -10446.557     -10446.557     -10521.768     -10521.768      291.07382      291.07382      28009.99       28009.99       1512.6986      1512.6986    
    224000  -10442.391     -10442.391     -10517.789     -10517.789      291.80105      291.80105      28021.543      28021.543      1366.6542      1366.6542    
Loop time of 105.666 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.352 hours/ns, 9.464 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    | 105.13     | 105.13     | 105.13     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081667   | 0.081667   | 0.081667   |   0.0 |  0.08
Output  | 0.00016481 | 0.00016481 | 0.00016481 |   0.0 |  0.00
Modify  | 0.39708    | 0.39708    | 0.39708    |   0.0 |  0.38
Other   |            | 0.05878    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3140 ave        3140 max        3140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118932 ave      118932 max      118932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118932
Ave neighs/atom = 59.466
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.774859783546, Press = 0.466314032666484
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    224000  -10442.391     -10442.391     -10517.789     -10517.789      291.80105      291.80105      28021.543      28021.543      1366.6542      1366.6542    
    225000  -10443.678     -10443.678     -10520.975     -10520.975      299.14673      299.14673      28068          28068         -1466.1989     -1466.1989    
Loop time of 104.873 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.131 hours/ns, 9.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    | 104.34     | 104.34     | 104.34     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082483   | 0.082483   | 0.082483   |   0.0 |  0.08
Output  | 0.00016515 | 0.00016515 | 0.00016515 |   0.0 |  0.00
Modify  | 0.39446    | 0.39446    | 0.39446    |   0.0 |  0.38
Other   |            | 0.05919    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3170 ave        3170 max        3170 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118996 ave      118996 max      118996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118996
Ave neighs/atom = 59.498
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.776054338214, Press = 0.285947241636109
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    225000  -10443.678     -10443.678     -10520.975     -10520.975      299.14673      299.14673      28068          28068         -1466.1989     -1466.1989    
    226000  -10444.572     -10444.572     -10520.451     -10520.451      293.65819      293.65819      28031.27       28031.27       537.68793      537.68793    
Loop time of 105.612 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.337 hours/ns, 9.469 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    | 105.07     | 105.07     | 105.07     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082046   | 0.082046   | 0.082046   |   0.0 |  0.08
Output  | 0.00020884 | 0.00020884 | 0.00020884 |   0.0 |  0.00
Modify  | 0.39743    | 0.39743    | 0.39743    |   0.0 |  0.38
Other   |            | 0.05959    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3130 ave        3130 max        3130 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118922 ave      118922 max      118922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118922
Ave neighs/atom = 59.461
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.787737809533, Press = 0.163683417511858
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    226000  -10444.572     -10444.572     -10520.451     -10520.451      293.65819      293.65819      28031.27       28031.27       537.68793      537.68793    
    227000  -10443.19      -10443.19      -10520.316     -10520.316      298.48825      298.48825      28024.756      28024.756      971.2198       971.2198     
Loop time of 104.996 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.166 hours/ns, 9.524 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    | 104.46     | 104.46     | 104.46     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081484   | 0.081484   | 0.081484   |   0.0 |  0.08
Output  | 0.00016263 | 0.00016263 | 0.00016263 |   0.0 |  0.00
Modify  | 0.39542    | 0.39542    | 0.39542    |   0.0 |  0.38
Other   |            | 0.05887    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3124 ave        3124 max        3124 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119090 ave      119090 max      119090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119090
Ave neighs/atom = 59.545
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.789970074101, Press = 0.410754575787083
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    227000  -10443.19      -10443.19      -10520.316     -10520.316      298.48825      298.48825      28024.756      28024.756      971.2198       971.2198     
    228000  -10449.542     -10449.542     -10521.919     -10521.919      280.10639      280.10639      28113.346      28113.346     -4311.2649     -4311.2649    
Loop time of 104.433 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.009 hours/ns, 9.575 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    | 103.9      | 103.9      | 103.9      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081568   | 0.081568   | 0.081568   |   0.0 |  0.08
Output  | 0.00016629 | 0.00016629 | 0.00016629 |   0.0 |  0.00
Modify  | 0.39239    | 0.39239    | 0.39239    |   0.0 |  0.38
Other   |            | 0.05874    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3136 ave        3136 max        3136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119046 ave      119046 max      119046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119046
Ave neighs/atom = 59.523
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.786077541138, Press = 0.320887025324436
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    228000  -10449.542     -10449.542     -10521.919     -10521.919      280.10639      280.10639      28113.346      28113.346     -4311.2649     -4311.2649    
    229000  -10442.068     -10442.068     -10517.463     -10517.463      291.78727      291.78727      28033.876      28033.876      729.7768       729.7768     
Loop time of 103.107 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.838 ns/day, 28.641 hours/ns, 9.699 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    | 102.58     | 102.58     | 102.58     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078738   | 0.078738   | 0.078738   |   0.0 |  0.08
Output  | 0.00020866 | 0.00020866 | 0.00020866 |   0.0 |  0.00
Modify  | 0.38582    | 0.38582    | 0.38582    |   0.0 |  0.37
Other   |            | 0.05869    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3075 ave        3075 max        3075 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118758 ave      118758 max      118758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118758
Ave neighs/atom = 59.379
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.780315531583, Press = 0.00866435628624916
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    229000  -10442.068     -10442.068     -10517.463     -10517.463      291.78727      291.78727      28033.876      28033.876      729.7768       729.7768     
    230000  -10444.84      -10444.84      -10520.771     -10520.771      293.86046      293.86046      28019.734      28019.734      1206.4232      1206.4232    
Loop time of 103.873 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.854 hours/ns, 9.627 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.35     | 103.35     | 103.35     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080534   | 0.080534   | 0.080534   |   0.0 |  0.08
Output  | 0.00022539 | 0.00022539 | 0.00022539 |   0.0 |  0.00
Modify  | 0.38865    | 0.38865    | 0.38865    |   0.0 |  0.37
Other   |            | 0.05836    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3140 ave        3140 max        3140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119060 ave      119060 max      119060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119060
Ave neighs/atom = 59.53
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.790885374192, Press = 0.374971227179433
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    230000  -10444.84      -10444.84      -10520.771     -10520.771      293.86046      293.86046      28019.734      28019.734      1206.4232      1206.4232    
    231000  -10444.727     -10444.727     -10521.441     -10521.441      296.89019      296.89019      28062.088      28062.088     -1257.6647     -1257.6647    
Loop time of 104.351 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 28.986 hours/ns, 9.583 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    | 103.82     | 103.82     | 103.82     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080367   | 0.080367   | 0.080367   |   0.0 |  0.08
Output  | 0.0001657  | 0.0001657  | 0.0001657  |   0.0 |  0.00
Modify  | 0.39077    | 0.39077    | 0.39077    |   0.0 |  0.37
Other   |            | 0.05846    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3102 ave        3102 max        3102 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118964 ave      118964 max      118964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118964
Ave neighs/atom = 59.482
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.795650015076, Press = 0.297386945947585
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    231000  -10444.727     -10444.727     -10521.441     -10521.441      296.89019      296.89019      28062.088      28062.088     -1257.6647     -1257.6647    
    232000  -10440.183     -10440.183     -10516.844     -10516.844      296.68554      296.68554      28035.284      28035.284      667.20407      667.20407    
Loop time of 105.514 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.309 hours/ns, 9.477 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    | 104.98     | 104.98     | 104.98     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080971   | 0.080971   | 0.080971   |   0.0 |  0.08
Output  | 0.00016153 | 0.00016153 | 0.00016153 |   0.0 |  0.00
Modify  | 0.39713    | 0.39713    | 0.39713    |   0.0 |  0.38
Other   |            | 0.05956    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3103 ave        3103 max        3103 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118918 ave      118918 max      118918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118918
Ave neighs/atom = 59.459
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.808992389804, Press = 0.0949491093461694
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    232000  -10440.183     -10440.183     -10516.844     -10516.844      296.68554      296.68554      28035.284      28035.284      667.20407      667.20407    
    233000  -10445.568     -10445.568     -10520.086     -10520.086      288.39063      288.39063      28002.123      28002.123      2216.5187      2216.5187    
Loop time of 105.04 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.178 hours/ns, 9.520 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    | 104.5      | 104.5      | 104.5      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081175   | 0.081175   | 0.081175   |   0.0 |  0.08
Output  | 0.00020839 | 0.00020839 | 0.00020839 |   0.0 |  0.00
Modify  | 0.39604    | 0.39604    | 0.39604    |   0.0 |  0.38
Other   |            | 0.05947    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3122 ave        3122 max        3122 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118900 ave      118900 max      118900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118900
Ave neighs/atom = 59.45
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.813550191604, Press = 0.581426585855582
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    233000  -10445.568     -10445.568     -10520.086     -10520.086      288.39063      288.39063      28002.123      28002.123      2216.5187      2216.5187    
    234000  -10442.969     -10442.969     -10518.608     -10518.608      292.73013      292.73013      28104.76       28104.76      -3330.2773     -3330.2773    
Loop time of 103.81 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.836 hours/ns, 9.633 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    | 103.28     | 103.28     | 103.28     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08111    | 0.08111    | 0.08111    |   0.0 |  0.08
Output  | 0.00025562 | 0.00025562 | 0.00025562 |   0.0 |  0.00
Modify  | 0.38951    | 0.38951    | 0.38951    |   0.0 |  0.38
Other   |            | 0.05857    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3145 ave        3145 max        3145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119040 ave      119040 max      119040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119040
Ave neighs/atom = 59.52
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.819186920983, Press = 0.352161968746664
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    234000  -10442.969     -10442.969     -10518.608     -10518.608      292.73013      292.73013      28104.76       28104.76      -3330.2773     -3330.2773    
    235000  -10443.221     -10443.221     -10519.311     -10519.311      294.479        294.479        28035.427      28035.427      498.16985      498.16985    
Loop time of 106.443 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.568 hours/ns, 9.395 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    | 105.9      | 105.9      | 105.9      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083211   | 0.083211   | 0.083211   |   0.0 |  0.08
Output  | 0.00016608 | 0.00016608 | 0.00016608 |   0.0 |  0.00
Modify  | 0.40464    | 0.40464    | 0.40464    |   0.0 |  0.38
Other   |            | 0.05976    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3136 ave        3136 max        3136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118876 ave      118876 max      118876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118876
Ave neighs/atom = 59.438
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.823202181538, Press = 0.100476136567128
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    235000  -10443.221     -10443.221     -10519.311     -10519.311      294.479        294.479        28035.427      28035.427      498.16985      498.16985    
    236000  -10443.65      -10443.65      -10518.699     -10518.699      290.44596      290.44596      28017.872      28017.872      1395.8572      1395.8572    
Loop time of 104.742 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.095 hours/ns, 9.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    | 104.21     | 104.21     | 104.21     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082041   | 0.082041   | 0.082041   |   0.0 |  0.08
Output  | 0.00016473 | 0.00016473 | 0.00016473 |   0.0 |  0.00
Modify  | 0.394      | 0.394      | 0.394      |   0.0 |  0.38
Other   |            | 0.05918    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3167 ave        3167 max        3167 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119006 ave      119006 max      119006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119006
Ave neighs/atom = 59.503
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.833311295171, Press = 0.460172677644227
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    236000  -10443.65      -10443.65      -10518.699     -10518.699      290.44596      290.44596      28017.872      28017.872      1395.8572      1395.8572    
    237000  -10445.249     -10445.249     -10519.638     -10519.638      287.894        287.894        28073.28       28073.28      -1740.1345     -1740.1345    
Loop time of 105.982 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.439 hours/ns, 9.436 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    | 105.44     | 105.44     | 105.44     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081956   | 0.081956   | 0.081956   |   0.0 |  0.08
Output  | 0.00016844 | 0.00016844 | 0.00016844 |   0.0 |  0.00
Modify  | 0.39942    | 0.39942    | 0.39942    |   0.0 |  0.38
Other   |            | 0.05888    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3135 ave        3135 max        3135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119070 ave      119070 max      119070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119070
Ave neighs/atom = 59.535
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.825573787343, Press = 0.336539089089344
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    237000  -10445.249     -10445.249     -10519.638     -10519.638      287.894        287.894        28073.28       28073.28      -1740.1345     -1740.1345    
    238000  -10444.133     -10444.133     -10520.676     -10520.676      296.22996      296.22996      28035.106      28035.106      346.46812      346.46812    
Loop time of 107.288 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.805 ns/day, 29.802 hours/ns, 9.321 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    | 106.73     | 106.73     | 106.73     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083851   | 0.083851   | 0.083851   |   0.0 |  0.08
Output  | 0.00021246 | 0.00021246 | 0.00021246 |   0.0 |  0.00
Modify  | 0.41037    | 0.41037    | 0.41037    |   0.0 |  0.38
Other   |            | 0.05984    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3141 ave        3141 max        3141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118970 ave      118970 max      118970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118970
Ave neighs/atom = 59.485
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.82209832832, Press = 0.0669297067381022
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    238000  -10444.133     -10444.133     -10520.676     -10520.676      296.22996      296.22996      28035.106      28035.106      346.46812      346.46812    
    239000  -10447.319     -10447.319     -10523.419     -10523.419      294.51338      294.51338      27982.015      27982.015      2999.8935      2999.8935    
Loop time of 106.39 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.553 hours/ns, 9.399 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    | 105.85     | 105.85     | 105.85     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082108   | 0.082108   | 0.082108   |   0.0 |  0.08
Output  | 0.00019578 | 0.00019578 | 0.00019578 |   0.0 |  0.00
Modify  | 0.40255    | 0.40255    | 0.40255    |   0.0 |  0.38
Other   |            | 0.05958    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3103 ave        3103 max        3103 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118974 ave      118974 max      118974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118974
Ave neighs/atom = 59.487
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.81516285019, Press = 0.56688849346681
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    239000  -10447.319     -10447.319     -10523.419     -10523.419      294.51338      294.51338      27982.015      27982.015      2999.8935      2999.8935    
    240000  -10444.253     -10444.253     -10518.897     -10518.897      288.87808      288.87808      28105.363      28105.363     -3371.6663     -3371.6663    
Loop time of 105.402 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.278 hours/ns, 9.488 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    | 104.86     | 104.86     | 104.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081205   | 0.081205   | 0.081205   |   0.0 |  0.08
Output  | 0.0001644  | 0.0001644  | 0.0001644  |   0.0 |  0.00
Modify  | 0.39693    | 0.39693    | 0.39693    |   0.0 |  0.38
Other   |            | 0.05949    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3116 ave        3116 max        3116 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119058 ave      119058 max      119058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119058
Ave neighs/atom = 59.529
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.810027277739, Press = 0.458623809167403
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    240000  -10444.253     -10444.253     -10518.897     -10518.897      288.87808      288.87808      28105.363      28105.363     -3371.6663     -3371.6663    
    241000  -10446.375     -10446.375     -10520.204     -10520.204      285.72696      285.72696      28036.246      28036.246      85.215902      85.215902    
Loop time of 103.876 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.854 hours/ns, 9.627 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.34     | 103.34     | 103.34     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079693   | 0.079693   | 0.079693   |   0.0 |  0.08
Output  | 0.00016458 | 0.00016458 | 0.00016458 |   0.0 |  0.00
Modify  | 0.39216    | 0.39216    | 0.39216    |   0.0 |  0.38
Other   |            | 0.05879    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3094 ave        3094 max        3094 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118788 ave      118788 max      118788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118788
Ave neighs/atom = 59.394
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.810135428309, Press = 0.109786650004584
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    241000  -10446.375     -10446.375     -10520.204     -10520.204      285.72696      285.72696      28036.246      28036.246      85.215902      85.215902    
    242000  -10443.996     -10443.996     -10518.882     -10518.882      289.81442      289.81442      28017.336      28017.336      1334.1723      1334.1723    
Loop time of 105.114 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.198 hours/ns, 9.513 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.58     | 104.58     | 104.58     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081113   | 0.081113   | 0.081113   |   0.0 |  0.08
Output  | 0.0004883  | 0.0004883  | 0.0004883  |   0.0 |  0.00
Modify  | 0.39493    | 0.39493    | 0.39493    |   0.0 |  0.38
Other   |            | 0.0589     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3097 ave        3097 max        3097 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118928 ave      118928 max      118928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118928
Ave neighs/atom = 59.464
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.811935720584, Press = 0.410324451174722
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    242000  -10443.996     -10443.996     -10518.882     -10518.882      289.81442      289.81442      28017.336      28017.336      1334.1723      1334.1723    
    243000  -10447.505     -10447.505     -10521.291     -10521.291      285.56041      285.56041      28066.698      28066.698     -1533.9027     -1533.9027    
Loop time of 106.488 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.580 hours/ns, 9.391 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    | 105.94     | 105.94     | 105.94     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081808   | 0.081808   | 0.081808   |   0.0 |  0.08
Output  | 0.00016388 | 0.00016388 | 0.00016388 |   0.0 |  0.00
Modify  | 0.40191    | 0.40191    | 0.40191    |   0.0 |  0.38
Other   |            | 0.05991    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3101 ave        3101 max        3101 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119018 ave      119018 max      119018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119018
Ave neighs/atom = 59.509
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.803741152075, Press = 0.357809178895941
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    243000  -10447.505     -10447.505     -10521.291     -10521.291      285.56041      285.56041      28066.698      28066.698     -1533.9027     -1533.9027    
    244000  -10443.946     -10443.946     -10521.229     -10521.229      299.09485      299.09485      28035.001      28035.001      302.66808      302.66808    
Loop time of 106.314 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.532 hours/ns, 9.406 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    | 105.77     | 105.77     | 105.77     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082665   | 0.082665   | 0.082665   |   0.0 |  0.08
Output  | 0.00016485 | 0.00016485 | 0.00016485 |   0.0 |  0.00
Modify  | 0.40245    | 0.40245    | 0.40245    |   0.0 |  0.38
Other   |            | 0.05977    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3138 ave        3138 max        3138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118892 ave      118892 max      118892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118892
Ave neighs/atom = 59.446
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.806529174401, Press = 0.0186236645290654
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    244000  -10443.946     -10443.946     -10521.229     -10521.229      299.09485      299.09485      28035.001      28035.001      302.66808      302.66808    
    245000  -10444.122     -10444.122     -10518.679     -10518.679      288.54388      288.54388      27976.26       27976.26       3650.4542      3650.4542    
Loop time of 105.394 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.276 hours/ns, 9.488 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    | 104.86     | 104.86     | 104.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081924   | 0.081924   | 0.081924   |   0.0 |  0.08
Output  | 0.00019923 | 0.00019923 | 0.00019923 |   0.0 |  0.00
Modify  | 0.39843    | 0.39843    | 0.39843    |   0.0 |  0.38
Other   |            | 0.05878    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3138 ave        3138 max        3138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118984 ave      118984 max      118984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118984
Ave neighs/atom = 59.492
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.812287496134, Press = 0.613558792709767
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    245000  -10444.122     -10444.122     -10518.679     -10518.679      288.54388      288.54388      27976.26       27976.26       3650.4542      3650.4542    
    246000  -10443.498     -10443.498     -10520.559     -10520.559      298.23303      298.23303      28070.984      28070.984     -1662.9296     -1662.9296    
Loop time of 104.976 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.160 hours/ns, 9.526 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    | 104.44     | 104.44     | 104.44     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081616   | 0.081616   | 0.081616   |   0.0 |  0.08
Output  | 0.00016388 | 0.00016388 | 0.00016388 |   0.0 |  0.00
Modify  | 0.39186    | 0.39186    | 0.39186    |   0.0 |  0.37
Other   |            | 0.05897    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3185 ave        3185 max        3185 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119132 ave      119132 max      119132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119132
Ave neighs/atom = 59.566
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.827423239666, Press = 0.384853699732864
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    246000  -10443.498     -10443.498     -10520.559     -10520.559      298.23303      298.23303      28070.984      28070.984     -1662.9296     -1662.9296    
    247000  -10442.812     -10442.812     -10520.116     -10520.116      299.17337      299.17337      28045.965      28045.965     -176.41871     -176.41871    
Loop time of 104.64 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.067 hours/ns, 9.557 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.11     | 104.11     | 104.11     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081433   | 0.081433   | 0.081433   |   0.0 |  0.08
Output  | 0.00016322 | 0.00016322 | 0.00016322 |   0.0 |  0.00
Modify  | 0.39283    | 0.39283    | 0.39283    |   0.0 |  0.38
Other   |            | 0.05912    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3140 ave        3140 max        3140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118916 ave      118916 max      118916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118916
Ave neighs/atom = 59.458
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.82784898121, Press = 0.196544246700491
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    247000  -10442.812     -10442.812     -10520.116     -10520.116      299.17337      299.17337      28045.965      28045.965     -176.41871     -176.41871    
    248000  -10445.324     -10445.324     -10519.84      -10519.84       288.38324      288.38324      28017.993      28017.993      1170.1893      1170.1893    
Loop time of 104.763 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.101 hours/ns, 9.545 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    | 104.23     | 104.23     | 104.23     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081512   | 0.081512   | 0.081512   |   0.0 |  0.08
Output  | 0.00024514 | 0.00024514 | 0.00024514 |   0.0 |  0.00
Modify  | 0.39604    | 0.39604    | 0.39604    |   0.0 |  0.38
Other   |            | 0.05903    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3146 ave        3146 max        3146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118842 ave      118842 max      118842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118842
Ave neighs/atom = 59.421
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.83682952414, Press = 0.372041533926162
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    248000  -10445.324     -10445.324     -10519.84      -10519.84       288.38324      288.38324      28017.993      28017.993      1170.1893      1170.1893    
    249000  -10440.785     -10440.785     -10517.425     -10517.425      296.6045       296.6045       28074.751      28074.751     -1529.5628     -1529.5628    
Loop time of 106.137 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.483 hours/ns, 9.422 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    | 105.59     | 105.59     | 105.59     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083042   | 0.083042   | 0.083042   |   0.0 |  0.08
Output  | 0.00019539 | 0.00019539 | 0.00019539 |   0.0 |  0.00
Modify  | 0.40199    | 0.40199    | 0.40199    |   0.0 |  0.38
Other   |            | 0.05973    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3146 ave        3146 max        3146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119010 ave      119010 max      119010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119010
Ave neighs/atom = 59.505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.847056862494, Press = 0.428608241051855
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    249000  -10440.785     -10440.785     -10517.425     -10517.425      296.6045       296.6045       28074.751      28074.751     -1529.5628     -1529.5628    
    250000  -10445.257     -10445.257     -10520.716     -10520.716      292.03471      292.03471      28046.637      28046.637     -434.4192      -434.4192     
Loop time of 104.376 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 28.993 hours/ns, 9.581 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    | 103.84     | 103.84     | 103.84     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080598   | 0.080598   | 0.080598   |   0.0 |  0.08
Output  | 0.00022816 | 0.00022816 | 0.00022816 |   0.0 |  0.00
Modify  | 0.39358    | 0.39358    | 0.39358    |   0.0 |  0.38
Other   |            | 0.05893    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3119 ave        3119 max        3119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118954 ave      118954 max      118954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118954
Ave neighs/atom = 59.477
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.85507042011, Press = -0.078819044401571
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    250000  -10445.257     -10445.257     -10520.716     -10520.716      292.03471      292.03471      28046.637      28046.637     -434.4192      -434.4192     
    251000  -10444.604     -10444.604     -10519.101     -10519.101      288.31116      288.31116      27998.338      27998.338      2453.0361      2453.0361    
Loop time of 102.555 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.842 ns/day, 28.488 hours/ns, 9.751 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    | 102.03     | 102.03     | 102.03     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079657   | 0.079657   | 0.079657   |   0.0 |  0.08
Output  | 0.00016617 | 0.00016617 | 0.00016617 |   0.0 |  0.00
Modify  | 0.38252    | 0.38252    | 0.38252    |   0.0 |  0.37
Other   |            | 0.05779    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3138 ave        3138 max        3138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118980 ave      118980 max      118980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118980
Ave neighs/atom = 59.49
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.855793904804, Press = 0.451167575597302
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    251000  -10444.604     -10444.604     -10519.101     -10519.101      288.31116      288.31116      27998.338      27998.338      2453.0361      2453.0361    
    252000  -10446.135     -10446.135     -10522.658     -10522.658      296.15575      296.15575      28054.344      28054.344     -929.67009     -929.67009    
Loop time of 101.759 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.849 ns/day, 28.266 hours/ns, 9.827 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    | 101.24     | 101.24     | 101.24     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07933    | 0.07933    | 0.07933    |   0.0 |  0.08
Output  | 0.00020636 | 0.00020636 | 0.00020636 |   0.0 |  0.00
Modify  | 0.38003    | 0.38003    | 0.38003    |   0.0 |  0.37
Other   |            | 0.05795    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3138 ave        3138 max        3138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119082 ave      119082 max      119082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119082
Ave neighs/atom = 59.541
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.858727307521, Press = 0.331238802726618
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    252000  -10446.135     -10446.135     -10522.658     -10522.658      296.15575      296.15575      28054.344      28054.344     -929.67009     -929.67009    
    253000  -10443.132     -10443.132     -10519.991     -10519.991      297.45202      297.45202      28041.717      28041.717      91.206942      91.206942    
Loop time of 102.124 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.846 ns/day, 28.368 hours/ns, 9.792 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    | 101.6      | 101.6      | 101.6      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079669   | 0.079669   | 0.079669   |   0.0 |  0.08
Output  | 0.00016407 | 0.00016407 | 0.00016407 |   0.0 |  0.00
Modify  | 0.38432    | 0.38432    | 0.38432    |   0.0 |  0.38
Other   |            | 0.058      |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3107 ave        3107 max        3107 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118942 ave      118942 max      118942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118942
Ave neighs/atom = 59.471
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.858270800693, Press = 0.238663802925
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    253000  -10443.132     -10443.132     -10519.991     -10519.991      297.45202      297.45202      28041.717      28041.717      91.206942      91.206942    
    254000  -10447.016     -10447.016     -10521.967     -10521.967      290.07026      290.07026      28019.15       28019.15       987.08612      987.08612    
Loop time of 106.039 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.455 hours/ns, 9.431 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.49     | 105.49     | 105.49     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081755   | 0.081755   | 0.081755   |   0.0 |  0.08
Output  | 0.00016524 | 0.00016524 | 0.00016524 |   0.0 |  0.00
Modify  | 0.40427    | 0.40427    | 0.40427    |   0.0 |  0.38
Other   |            | 0.05942    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3102 ave        3102 max        3102 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119006 ave      119006 max      119006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119006
Ave neighs/atom = 59.503
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.850339258007, Press = 0.39447537046095
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    254000  -10447.016     -10447.016     -10521.967     -10521.967      290.07026      290.07026      28019.15       28019.15       987.08612      987.08612    
    255000  -10443.249     -10443.249     -10519.283     -10519.283      294.26006      294.26006      28087.201      28087.201     -2319.7934     -2319.7934    
Loop time of 104.695 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.082 hours/ns, 9.552 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    | 104.16     | 104.16     | 104.16     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08079    | 0.08079    | 0.08079    |   0.0 |  0.08
Output  | 0.00017042 | 0.00017042 | 0.00017042 |   0.0 |  0.00
Modify  | 0.39231    | 0.39231    | 0.39231    |   0.0 |  0.37
Other   |            | 0.05884    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3123 ave        3123 max        3123 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118988 ave      118988 max      118988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118988
Ave neighs/atom = 59.494
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.84423217513, Press = 0.341014841529605
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    255000  -10443.249     -10443.249     -10519.283     -10519.283      294.26006      294.26006      28087.201      28087.201     -2319.7934     -2319.7934    
    256000  -10444.11      -10444.11      -10521.459     -10521.459      299.3464       299.3464       28038.987      28038.987      154.70803      154.70803    
Loop time of 106.283 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.523 hours/ns, 9.409 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    | 105.74     | 105.74     | 105.74     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081235   | 0.081235   | 0.081235   |   0.0 |  0.08
Output  | 0.0001664  | 0.0001664  | 0.0001664  |   0.0 |  0.00
Modify  | 0.39952    | 0.39952    | 0.39952    |   0.0 |  0.38
Other   |            | 0.05925    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3094 ave        3094 max        3094 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118940 ave      118940 max      118940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118940
Ave neighs/atom = 59.47
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.838345953797, Press = 0.0052916704636594
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    256000  -10444.11      -10444.11      -10521.459     -10521.459      299.3464       299.3464       28038.987      28038.987      154.70803      154.70803    
    257000  -10441.714     -10441.714     -10520.585     -10520.585      305.24183      305.24183      28020.756      28020.756      1340.3478      1340.3478    
Loop time of 104.66 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.072 hours/ns, 9.555 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    | 104.13     | 104.13     | 104.13     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081657   | 0.081657   | 0.081657   |   0.0 |  0.08
Output  | 0.00023664 | 0.00023664 | 0.00023664 |   0.0 |  0.00
Modify  | 0.39244    | 0.39244    | 0.39244    |   0.0 |  0.37
Other   |            | 0.05944    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3157 ave        3157 max        3157 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119002 ave      119002 max      119002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119002
Ave neighs/atom = 59.501
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.834329085566, Press = 0.442203014522842
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    257000  -10441.714     -10441.714     -10520.585     -10520.585      305.24183      305.24183      28020.756      28020.756      1340.3478      1340.3478    
    258000  -10446.733     -10446.733     -10522.804     -10522.804      294.40019      294.40019      28054.504      28054.504     -824.25039     -824.25039    
Loop time of 103.998 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.888 hours/ns, 9.616 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    | 103.47     | 103.47     | 103.47     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081103   | 0.081103   | 0.081103   |   0.0 |  0.08
Output  | 0.00016343 | 0.00016343 | 0.00016343 |   0.0 |  0.00
Modify  | 0.3915     | 0.3915     | 0.3915     |   0.0 |  0.38
Other   |            | 0.05872    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3143 ave        3143 max        3143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119028 ave      119028 max      119028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119028
Ave neighs/atom = 59.514
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.835529284247, Press = 0.305860080607573
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    258000  -10446.733     -10446.733     -10522.804     -10522.804      294.40019      294.40019      28054.504      28054.504     -824.25039     -824.25039    
    259000  -10444.035     -10444.035     -10518.695     -10518.695      288.94396      288.94396      28038.56       28038.56       427.64793      427.64793    
Loop time of 105.162 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.212 hours/ns, 9.509 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    | 104.63     | 104.63     | 104.63     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082071   | 0.082071   | 0.082071   |   0.0 |  0.08
Output  | 0.00016564 | 0.00016564 | 0.00016564 |   0.0 |  0.00
Modify  | 0.39508    | 0.39508    | 0.39508    |   0.0 |  0.38
Other   |            | 0.05893    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3154 ave        3154 max        3154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118898 ave      118898 max      118898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118898
Ave neighs/atom = 59.449
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.827933795276, Press = 0.263708312126329
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    259000  -10444.035     -10444.035     -10518.695     -10518.695      288.94396      288.94396      28038.56       28038.56       427.64793      427.64793    
    260000  -10445.766     -10445.766     -10522.258     -10522.258      296.03324      296.03324      28037.33       28037.33       45.121682      45.121682    
Loop time of 105.139 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.205 hours/ns, 9.511 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    | 104.6      | 104.6      | 104.6      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082407   | 0.082407   | 0.082407   |   0.0 |  0.08
Output  | 0.00016397 | 0.00016397 | 0.00016397 |   0.0 |  0.00
Modify  | 0.39412    | 0.39412    | 0.39412    |   0.0 |  0.37
Other   |            | 0.05961    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3160 ave        3160 max        3160 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119000 ave      119000 max      119000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119000
Ave neighs/atom = 59.5
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.831188136572, Press = 0.309756316325268
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    260000  -10445.766     -10445.766     -10522.258     -10522.258      296.03324      296.03324      28037.33       28037.33       45.121682      45.121682    
    261000  -10440.804     -10440.804     -10516.727     -10516.727      293.82878      293.82878      28064.256      28064.256     -879.34555     -879.34555    
Loop time of 105.461 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.295 hours/ns, 9.482 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    | 104.92     | 104.92     | 104.92     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080945   | 0.080945   | 0.080945   |   0.0 |  0.08
Output  | 0.00016775 | 0.00016775 | 0.00016775 |   0.0 |  0.00
Modify  | 0.39641    | 0.39641    | 0.39641    |   0.0 |  0.38
Other   |            | 0.0589     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3107 ave        3107 max        3107 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119018 ave      119018 max      119018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119018
Ave neighs/atom = 59.509
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.839011195177, Press = 0.301394491709285
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    261000  -10440.804     -10440.804     -10516.727     -10516.727      293.82878      293.82878      28064.256      28064.256     -879.34555     -879.34555    
    262000  -10445.249     -10445.249     -10521.985     -10521.985      296.97626      296.97626      28043.761      28043.761     -227.64038     -227.64038    
Loop time of 102.976 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.605 hours/ns, 9.711 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    | 102.45     | 102.45     | 102.45     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080553   | 0.080553   | 0.080553   |   0.0 |  0.08
Output  | 0.00024855 | 0.00024855 | 0.00024855 |   0.0 |  0.00
Modify  | 0.38646    | 0.38646    | 0.38646    |   0.0 |  0.38
Other   |            | 0.05781    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3144 ave        3144 max        3144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118966 ave      118966 max      118966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118966
Ave neighs/atom = 59.483
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.845753401102, Press = 0.133698894459008
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    262000  -10445.249     -10445.249     -10521.985     -10521.985      296.97626      296.97626      28043.761      28043.761     -227.64038     -227.64038    
    263000  -10444.4       -10444.4       -10521.288     -10521.288      297.56437      297.56437      28016.988      28016.988      1447.8256      1447.8256    
Loop time of 106.18 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.494 hours/ns, 9.418 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    | 105.63     | 105.63     | 105.63     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082182   | 0.082182   | 0.082182   |   0.0 |  0.08
Output  | 0.0001634  | 0.0001634  | 0.0001634  |   0.0 |  0.00
Modify  | 0.40563    | 0.40563    | 0.40563    |   0.0 |  0.38
Other   |            | 0.05999    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3125 ave        3125 max        3125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118866 ave      118866 max      118866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118866
Ave neighs/atom = 59.433
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.854562538658, Press = 0.336300749757065
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    263000  -10444.4       -10444.4       -10521.288     -10521.288      297.56437      297.56437      28016.988      28016.988      1447.8256      1447.8256    
    264000  -10446.602     -10446.602     -10520.61      -10520.61       286.4153       286.4153       28068.894      28068.894     -1457.5374     -1457.5374    
Loop time of 105.118 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.199 hours/ns, 9.513 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.58     | 104.58     | 104.58     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080725   | 0.080725   | 0.080725   |   0.0 |  0.08
Output  | 0.00016465 | 0.00016465 | 0.00016465 |   0.0 |  0.00
Modify  | 0.39355    | 0.39355    | 0.39355    |   0.0 |  0.37
Other   |            | 0.05906    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3099 ave        3099 max        3099 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119042 ave      119042 max      119042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119042
Ave neighs/atom = 59.521
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.853897697707, Press = 0.374865553873458
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    264000  -10446.602     -10446.602     -10520.61      -10520.61       286.4153       286.4153       28068.894      28068.894     -1457.5374     -1457.5374    
    265000  -10445.72      -10445.72      -10520.736     -10520.736      290.32013      290.32013      28048.03       28048.03      -426.68266     -426.68266    
Loop time of 104.346 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 28.985 hours/ns, 9.584 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    | 103.81     | 103.81     | 103.81     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080906   | 0.080906   | 0.080906   |   0.0 |  0.08
Output  | 0.00016572 | 0.00016572 | 0.00016572 |   0.0 |  0.00
Modify  | 0.39317    | 0.39317    | 0.39317    |   0.0 |  0.38
Other   |            | 0.05872    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3114 ave        3114 max        3114 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118840 ave      118840 max      118840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118840
Ave neighs/atom = 59.42
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.854736166346, Press = 0.00530975355779248
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    265000  -10445.72      -10445.72      -10520.736     -10520.736      290.32013      290.32013      28048.03       28048.03      -426.68266     -426.68266    
    266000  -10443.252     -10443.252     -10518.518     -10518.518      291.28656      291.28656      27979.623      27979.623      3526.1875      3526.1875    
Loop time of 104.811 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.114 hours/ns, 9.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    | 104.27     | 104.27     | 104.27     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080814   | 0.080814   | 0.080814   |   0.0 |  0.08
Output  | 0.00020513 | 0.00020513 | 0.00020513 |   0.0 |  0.00
Modify  | 0.39721    | 0.39721    | 0.39721    |   0.0 |  0.38
Other   |            | 0.05852    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3155 ave        3155 max        3155 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118980 ave      118980 max      118980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118980
Ave neighs/atom = 59.49
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.847821109893, Press = 0.406870355435247
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    266000  -10443.252     -10443.252     -10518.518     -10518.518      291.28656      291.28656      27979.623      27979.623      3526.1875      3526.1875    
    267000  -10447.534     -10447.534     -10521.136     -10521.136      284.84678      284.84678      28061.76       28061.76      -1266.946      -1266.946     
Loop time of 105.027 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.174 hours/ns, 9.521 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    | 104.49     | 104.49     | 104.49     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081912   | 0.081912   | 0.081912   |   0.0 |  0.08
Output  | 0.00016289 | 0.00016289 | 0.00016289 |   0.0 |  0.00
Modify  | 0.397      | 0.397      | 0.397      |   0.0 |  0.38
Other   |            | 0.05949    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3152 ave        3152 max        3152 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119146 ave      119146 max      119146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119146
Ave neighs/atom = 59.573
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.844801334678, Press = 0.405079426802747
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    267000  -10447.534     -10447.534     -10521.136     -10521.136      284.84678      284.84678      28061.76       28061.76      -1266.946      -1266.946     
    268000  -10445.389     -10445.389     -10519.414     -10519.414      286.48492      286.48492      28044.805      28044.805     -145.88331     -145.88331    
Loop time of 105.097 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.194 hours/ns, 9.515 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    | 104.56     | 104.56     | 104.56     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082417   | 0.082417   | 0.082417   |   0.0 |  0.08
Output  | 0.00016446 | 0.00016446 | 0.00016446 |   0.0 |  0.00
Modify  | 0.39722    | 0.39722    | 0.39722    |   0.0 |  0.38
Other   |            | 0.05908    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3140 ave        3140 max        3140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118890 ave      118890 max      118890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118890
Ave neighs/atom = 59.445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.84956094729, Press = 0.145029281021884
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    268000  -10445.389     -10445.389     -10519.414     -10519.414      286.48492      286.48492      28044.805      28044.805     -145.88331     -145.88331    
    269000  -10444.507     -10444.507     -10520.723     -10520.723      294.9668       294.9668       28027.433      28027.433      769.13003      769.13003    
Loop time of 104.354 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 28.987 hours/ns, 9.583 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    | 103.82     | 103.82     | 103.82     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081324   | 0.081324   | 0.081324   |   0.0 |  0.08
Output  | 0.00016485 | 0.00016485 | 0.00016485 |   0.0 |  0.00
Modify  | 0.39283    | 0.39283    | 0.39283    |   0.0 |  0.38
Other   |            | 0.05864    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3135 ave        3135 max        3135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118920 ave      118920 max      118920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118920
Ave neighs/atom = 59.46
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.856601993181, Press = 0.304759130456901
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    269000  -10444.507     -10444.507     -10520.723     -10520.723      294.9668       294.9668       28027.433      28027.433      769.13003      769.13003    
    270000  -10446.116     -10446.116     -10521.025     -10521.025      289.90536      289.90536      28062.236      28062.236     -1220.1995     -1220.1995    
Loop time of 105.158 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.211 hours/ns, 9.510 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    | 104.62     | 104.62     | 104.62     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081076   | 0.081076   | 0.081076   |   0.0 |  0.08
Output  | 0.00016278 | 0.00016278 | 0.00016278 |   0.0 |  0.00
Modify  | 0.39604    | 0.39604    | 0.39604    |   0.0 |  0.38
Other   |            | 0.05955    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3115 ave        3115 max        3115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119016 ave      119016 max      119016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119016
Ave neighs/atom = 59.508
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.864727795542, Press = 0.325124521329812
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    270000  -10446.116     -10446.116     -10521.025     -10521.025      289.90536      289.90536      28062.236      28062.236     -1220.1995     -1220.1995    
    271000  -10443.179     -10443.179     -10519.196     -10519.196      294.19243      294.19243      28047.407      28047.407     -195.8995      -195.8995     
Loop time of 103.503 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.835 ns/day, 28.751 hours/ns, 9.662 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    | 102.98     | 102.98     | 102.98     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081281   | 0.081281   | 0.081281   |   0.0 |  0.08
Output  | 0.00016522 | 0.00016522 | 0.00016522 |   0.0 |  0.00
Modify  | 0.38719    | 0.38719    | 0.38719    |   0.0 |  0.37
Other   |            | 0.05931    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3136 ave        3136 max        3136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118912 ave      118912 max      118912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118912
Ave neighs/atom = 59.456
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.863882306082, Press = -0.043916316630994
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    271000  -10443.179     -10443.179     -10519.196     -10519.196      294.19243      294.19243      28047.407      28047.407     -195.8995      -195.8995     
    272000  -10443.579     -10443.579     -10517.438     -10517.438      285.84086      285.84086      27996.523      27996.523      2679.2023      2679.2023    
Loop time of 103.467 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.835 ns/day, 28.741 hours/ns, 9.665 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.94     | 102.94     | 102.94     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080918   | 0.080918   | 0.080918   |   0.0 |  0.08
Output  | 0.00016299 | 0.00016299 | 0.00016299 |   0.0 |  0.00
Modify  | 0.38847    | 0.38847    | 0.38847    |   0.0 |  0.38
Other   |            | 0.05885    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3140 ave        3140 max        3140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118950 ave      118950 max      118950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118950
Ave neighs/atom = 59.475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.86632975029, Press = 0.43320244116575
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    272000  -10443.579     -10443.579     -10517.438     -10517.438      285.84086      285.84086      27996.523      27996.523      2679.2023      2679.2023    
    273000  -10445.15      -10445.15      -10520.13      -10520.13       290.18108      290.18108      28066.205      28066.205     -1446.5027     -1446.5027    
Loop time of 105.679 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.355 hours/ns, 9.463 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.14     | 105.14     | 105.14     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082319   | 0.082319   | 0.082319   |   0.0 |  0.08
Output  | 0.00020611 | 0.00020611 | 0.00020611 |   0.0 |  0.00
Modify  | 0.40071    | 0.40071    | 0.40071    |   0.0 |  0.38
Other   |            | 0.05949    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3147 ave        3147 max        3147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119078 ave      119078 max      119078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119078
Ave neighs/atom = 59.539
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.875749645263, Press = 0.331706480385185
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    273000  -10445.15      -10445.15      -10520.13      -10520.13       290.18108      290.18108      28066.205      28066.205     -1446.5027     -1446.5027    
    274000  -10439.874     -10439.874     -10516.787     -10516.787      297.66094      297.66094      28045.014      28045.014      200.10639      200.10639    
Loop time of 106.092 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.470 hours/ns, 9.426 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    | 105.55     | 105.55     | 105.55     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082171   | 0.082171   | 0.082171   |   0.0 |  0.08
Output  | 0.00027718 | 0.00027718 | 0.00027718 |   0.0 |  0.00
Modify  | 0.39994    | 0.39994    | 0.39994    |   0.0 |  0.38
Other   |            | 0.05904    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3121 ave        3121 max        3121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118864 ave      118864 max      118864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118864
Ave neighs/atom = 59.432
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.88406373837, Press = 0.138847767828051
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    274000  -10439.874     -10439.874     -10516.787     -10516.787      297.66094      297.66094      28045.014      28045.014      200.10639      200.10639    
    275000  -10444.89      -10444.89      -10522.163     -10522.163      299.05335      299.05335      28028.966      28028.966      556.54035      556.54035    
Loop time of 105.477 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.299 hours/ns, 9.481 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.93     | 104.93     | 104.93     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082237   | 0.082237   | 0.082237   |   0.0 |  0.08
Output  | 0.0001652  | 0.0001652  | 0.0001652  |   0.0 |  0.00
Modify  | 0.39942    | 0.39942    | 0.39942    |   0.0 |  0.38
Other   |            | 0.06034    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3153 ave        3153 max        3153 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118930 ave      118930 max      118930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118930
Ave neighs/atom = 59.465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.889832958271, Press = 0.330066149861301
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    275000  -10444.89      -10444.89      -10522.163     -10522.163      299.05335      299.05335      28028.966      28028.966      556.54035      556.54035    
    276000  -10445.431     -10445.431     -10519.912     -10519.912      288.24856      288.24856      28047.047      28047.047     -339.41668     -339.41668    
Loop time of 105.277 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.244 hours/ns, 9.499 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    | 104.74     | 104.74     | 104.74     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08104    | 0.08104    | 0.08104    |   0.0 |  0.08
Output  | 0.00016374 | 0.00016374 | 0.00016374 |   0.0 |  0.00
Modify  | 0.39766    | 0.39766    | 0.39766    |   0.0 |  0.38
Other   |            | 0.05838    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3118 ave        3118 max        3118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118940 ave      118940 max      118940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118940
Ave neighs/atom = 59.47
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.893300293089, Press = 0.256972625842055
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    276000  -10445.431     -10445.431     -10519.912     -10519.912      288.24856      288.24856      28047.047      28047.047     -339.41668     -339.41668    
    277000  -10441.049     -10441.049     -10517.205     -10517.205      294.73134      294.73134      28036.023      28036.023      511.29588      511.29588    
Loop time of 104.25 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.958 hours/ns, 9.592 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    | 103.72     | 103.72     | 103.72     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081325   | 0.081325   | 0.081325   |   0.0 |  0.08
Output  | 0.00020262 | 0.00020262 | 0.00020262 |   0.0 |  0.00
Modify  | 0.39335    | 0.39335    | 0.39335    |   0.0 |  0.38
Other   |            | 0.05887    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3137 ave        3137 max        3137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118950 ave      118950 max      118950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118950
Ave neighs/atom = 59.475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.900168576916, Press = 0.263397728201263
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    277000  -10441.049     -10441.049     -10517.205     -10517.205      294.73134      294.73134      28036.023      28036.023      511.29588      511.29588    
    278000  -10446.262     -10446.262     -10520.316     -10520.316      286.59393      286.59393      28050.129      28050.129     -617.08604     -617.08604    
Loop time of 104.543 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.040 hours/ns, 9.565 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    | 104.01     | 104.01     | 104.01     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081704   | 0.081704   | 0.081704   |   0.0 |  0.08
Output  | 0.00020736 | 0.00020736 | 0.00020736 |   0.0 |  0.00
Modify  | 0.39409    | 0.39409    | 0.39409    |   0.0 |  0.38
Other   |            | 0.05876    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3136 ave        3136 max        3136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119108 ave      119108 max      119108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119108
Ave neighs/atom = 59.554
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.905099721045, Press = 0.328651290958151
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    278000  -10446.262     -10446.262     -10520.316     -10520.316      286.59393      286.59393      28050.129      28050.129     -617.08604     -617.08604    
    279000  -10445.354     -10445.354     -10519.286     -10519.286      286.12412      286.12412      28061.977      28061.977     -1069.7654     -1069.7654    
Loop time of 106.636 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.621 hours/ns, 9.378 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    | 106.09     | 106.09     | 106.09     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081803   | 0.081803   | 0.081803   |   0.0 |  0.08
Output  | 0.00020955 | 0.00020955 | 0.00020955 |   0.0 |  0.00
Modify  | 0.40308    | 0.40308    | 0.40308    |   0.0 |  0.38
Other   |            | 0.0596     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3133 ave        3133 max        3133 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119024 ave      119024 max      119024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119024
Ave neighs/atom = 59.512
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.904477705279, Press = -0.00572256654831442
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    279000  -10445.354     -10445.354     -10519.286     -10519.286      286.12412      286.12412      28061.977      28061.977     -1069.7654     -1069.7654    
    280000  -10443.632     -10443.632     -10519.835     -10519.835      294.91444      294.91444      27980.349      27980.349      3265.0327      3265.0327    
Loop time of 102.976 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.604 hours/ns, 9.711 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    | 102.45     | 102.45     | 102.45     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080243   | 0.080243   | 0.080243   |   0.0 |  0.08
Output  | 0.00050811 | 0.00050811 | 0.00050811 |   0.0 |  0.00
Modify  | 0.38437    | 0.38437    | 0.38437    |   0.0 |  0.37
Other   |            | 0.05774    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3121 ave        3121 max        3121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118916 ave      118916 max      118916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118916
Ave neighs/atom = 59.458
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.895921660628, Press = 0.288261957335651
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    280000  -10443.632     -10443.632     -10519.835     -10519.835      294.91444      294.91444      27980.349      27980.349      3265.0327      3265.0327    
    281000  -10442.845     -10442.845     -10518.828     -10518.828      294.06249      294.06249      28065.564      28065.564     -1095.3847     -1095.3847    
Loop time of 104.248 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.958 hours/ns, 9.593 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    | 103.71     | 103.71     | 103.71     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081576   | 0.081576   | 0.081576   |   0.0 |  0.08
Output  | 0.00016452 | 0.00016452 | 0.00016452 |   0.0 |  0.00
Modify  | 0.39342    | 0.39342    | 0.39342    |   0.0 |  0.38
Other   |            | 0.05888    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3153 ave        3153 max        3153 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119146 ave      119146 max      119146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119146
Ave neighs/atom = 59.573
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.889959965673, Press = 0.411647923086143
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    281000  -10442.845     -10442.845     -10518.828     -10518.828      294.06249      294.06249      28065.564      28065.564     -1095.3847     -1095.3847    
    282000  -10448.957     -10448.957     -10522.744     -10522.744      285.56646      285.56646      28049.019      28049.019     -866.8333      -866.8333     
Loop time of 106.916 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.699 hours/ns, 9.353 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    | 106.37     | 106.37     | 106.37     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082535   | 0.082535   | 0.082535   |   0.0 |  0.08
Output  | 0.00020963 | 0.00020963 | 0.00020963 |   0.0 |  0.00
Modify  | 0.4052     | 0.4052     | 0.4052     |   0.0 |  0.38
Other   |            | 0.05982    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3105 ave        3105 max        3105 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118946 ave      118946 max      118946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118946
Ave neighs/atom = 59.473
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.88796849421, Press = 0.0865503331235927
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    282000  -10448.957     -10448.957     -10522.744     -10522.744      285.56646      285.56646      28049.019      28049.019     -866.8333      -866.8333     
    283000  -10443.028     -10443.028     -10516.893     -10516.893      285.86503      285.86503      28010.449      28010.449      1896.8283      1896.8283    
Loop time of 105.162 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.212 hours/ns, 9.509 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    | 104.62     | 104.62     | 104.62     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081672   | 0.081672   | 0.081672   |   0.0 |  0.08
Output  | 0.00016342 | 0.00016342 | 0.00016342 |   0.0 |  0.00
Modify  | 0.3985     | 0.3985     | 0.3985     |   0.0 |  0.38
Other   |            | 0.05926    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3140 ave        3140 max        3140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118950 ave      118950 max      118950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118950
Ave neighs/atom = 59.475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.879987741669, Press = 0.288742198292739
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    283000  -10443.028     -10443.028     -10516.893     -10516.893      285.86503      285.86503      28010.449      28010.449      1896.8283      1896.8283    
    284000  -10443.143     -10443.143     -10520.097     -10520.097      297.81688      297.81688      28067.02       28067.02      -1265.7632     -1265.7632    
Loop time of 105.401 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.278 hours/ns, 9.488 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    | 104.86     | 104.86     | 104.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081982   | 0.081982   | 0.081982   |   0.0 |  0.08
Output  | 0.00021163 | 0.00021163 | 0.00021163 |   0.0 |  0.00
Modify  | 0.3955     | 0.3955     | 0.3955     |   0.0 |  0.38
Other   |            | 0.05849    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3134 ave        3134 max        3134 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119036 ave      119036 max      119036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119036
Ave neighs/atom = 59.518
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.884404014989, Press = 0.346897000580816
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    284000  -10443.143     -10443.143     -10520.097     -10520.097      297.81688      297.81688      28067.02       28067.02      -1265.7632     -1265.7632    
    285000  -10444.052     -10444.052     -10519.14      -10519.14       290.60062      290.60062      28056.607      28056.607     -740.75133     -740.75133    
Loop time of 105.551 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.320 hours/ns, 9.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    | 105.01     | 105.01     | 105.01     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082546   | 0.082546   | 0.082546   |   0.0 |  0.08
Output  | 0.00016389 | 0.00016389 | 0.00016389 |   0.0 |  0.00
Modify  | 0.39929    | 0.39929    | 0.39929    |   0.0 |  0.38
Other   |            | 0.05949    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3139 ave        3139 max        3139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118876 ave      118876 max      118876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118876
Ave neighs/atom = 59.438
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.885996415917, Press = 0.0971881366631095
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    285000  -10444.052     -10444.052     -10519.14      -10519.14       290.60062      290.60062      28056.607      28056.607     -740.75133     -740.75133    
    286000  -10443.264     -10443.264     -10519.144     -10519.144      293.66362      293.66362      28000.048      28000.048      2536.2103      2536.2103    
Loop time of 102.302 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.845 ns/day, 28.417 hours/ns, 9.775 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    | 101.78     | 101.78     | 101.78     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080384   | 0.080384   | 0.080384   |   0.0 |  0.08
Output  | 0.00016553 | 0.00016553 | 0.00016553 |   0.0 |  0.00
Modify  | 0.383      | 0.383      | 0.383      |   0.0 |  0.37
Other   |            | 0.05796    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3129 ave        3129 max        3129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118880 ave      118880 max      118880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118880
Ave neighs/atom = 59.44
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.886386579202, Press = 0.291064186250553
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    286000  -10443.264     -10443.264     -10519.144     -10519.144      293.66362      293.66362      28000.048      28000.048      2536.2103      2536.2103    
    287000  -10447.032     -10447.032     -10520.474     -10520.474      284.2316       284.2316       28060.155      28060.155     -1173.4933     -1173.4933    
Loop time of 105.669 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.353 hours/ns, 9.463 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.13     | 105.13     | 105.13     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082451   | 0.082451   | 0.082451   |   0.0 |  0.08
Output  | 0.00016445 | 0.00016445 | 0.00016445 |   0.0 |  0.00
Modify  | 0.40023    | 0.40023    | 0.40023    |   0.0 |  0.38
Other   |            | 0.05946    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3135 ave        3135 max        3135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119018 ave      119018 max      119018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119018
Ave neighs/atom = 59.509
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.879416273694, Press = 0.424808926615968
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    287000  -10447.032     -10447.032     -10520.474     -10520.474      284.2316       284.2316       28060.155      28060.155     -1173.4933     -1173.4933    
    288000  -10442.704     -10442.704     -10519.845     -10519.845      298.54173      298.54173      28064.498      28064.498     -1118.7133     -1118.7133    
Loop time of 106.598 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.611 hours/ns, 9.381 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.05     | 106.05     | 106.05     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081747   | 0.081747   | 0.081747   |   0.0 |  0.08
Output  | 0.00016492 | 0.00016492 | 0.00016492 |   0.0 |  0.00
Modify  | 0.40425    | 0.40425    | 0.40425    |   0.0 |  0.38
Other   |            | 0.05991    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3119 ave        3119 max        3119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118908 ave      118908 max      118908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118908
Ave neighs/atom = 59.454
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.881310918961, Press = 0.130500240696734
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    288000  -10442.704     -10442.704     -10519.845     -10519.845      298.54173      298.54173      28064.498      28064.498     -1118.7133     -1118.7133    
    289000  -10445.151     -10445.151     -10519.914     -10519.914      289.34012      289.34012      28022.899      28022.899      1035.1048      1035.1048    
Loop time of 103.644 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.790 hours/ns, 9.648 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.12     | 103.12     | 103.12     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080599   | 0.080599   | 0.080599   |   0.0 |  0.08
Output  | 0.00020659 | 0.00020659 | 0.00020659 |   0.0 |  0.00
Modify  | 0.3895     | 0.3895     | 0.3895     |   0.0 |  0.38
Other   |            | 0.0588     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3119 ave        3119 max        3119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118808 ave      118808 max      118808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118808
Ave neighs/atom = 59.404
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.886529267811, Press = 0.208149644143407
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    289000  -10445.151     -10445.151     -10519.914     -10519.914      289.34012      289.34012      28022.899      28022.899      1035.1048      1035.1048    
    290000  -10438.263     -10438.263     -10515.468     -10515.468      298.79132      298.79132      28049.219      28049.219      147.56685      147.56685    
Loop time of 104.803 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.112 hours/ns, 9.542 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    | 104.27     | 104.27     | 104.27     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081506   | 0.081506   | 0.081506   |   0.0 |  0.08
Output  | 0.00020314 | 0.00020314 | 0.00020314 |   0.0 |  0.00
Modify  | 0.39384    | 0.39384    | 0.39384    |   0.0 |  0.38
Other   |            | 0.05927    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3149 ave        3149 max        3149 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118986 ave      118986 max      118986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118986
Ave neighs/atom = 59.493
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.891869219259, Press = 0.32665191655626
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    290000  -10438.263     -10438.263     -10515.468     -10515.468      298.79132      298.79132      28049.219      28049.219      147.56685      147.56685    
    291000  -10444.689     -10444.689     -10521.833     -10521.833      298.55691      298.55691      28063.628      28063.628     -1432.8836     -1432.8836    
Loop time of 106.168 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.491 hours/ns, 9.419 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    | 105.63     | 105.63     | 105.63     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081483   | 0.081483   | 0.081483   |   0.0 |  0.08
Output  | 0.00016557 | 0.00016557 | 0.00016557 |   0.0 |  0.00
Modify  | 0.40066    | 0.40066    | 0.40066    |   0.0 |  0.38
Other   |            | 0.0594     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3131 ave        3131 max        3131 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118994 ave      118994 max      118994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118994
Ave neighs/atom = 59.497
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.902484512796, Press = 0.208978534136862
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    291000  -10444.689     -10444.689     -10521.833     -10521.833      298.55691      298.55691      28063.628      28063.628     -1432.8836     -1432.8836    
    292000  -10447.391     -10447.391     -10522.654     -10522.654      291.27731      291.27731      28019.701      28019.701      838.11508      838.11508    
Loop time of 105.78 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.383 hours/ns, 9.454 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    | 105.24     | 105.24     | 105.24     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080508   | 0.080508   | 0.080508   |   0.0 |  0.08
Output  | 0.00016543 | 0.00016543 | 0.00016543 |   0.0 |  0.00
Modify  | 0.39876    | 0.39876    | 0.39876    |   0.0 |  0.38
Other   |            | 0.05914    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3095 ave        3095 max        3095 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118834 ave      118834 max      118834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118834
Ave neighs/atom = 59.417
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.90137735393, Press = 0.0377708374879284
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    292000  -10447.391     -10447.391     -10522.654     -10522.654      291.27731      291.27731      28019.701      28019.701      838.11508      838.11508    
    293000  -10444.14      -10444.14      -10521.335     -10521.335      298.75528      298.75528      28006.669      28006.669      1794.4503      1794.4503    
Loop time of 104.488 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.024 hours/ns, 9.571 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.95     | 103.95     | 103.95     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080919   | 0.080919   | 0.080919   |   0.0 |  0.08
Output  | 0.0002303  | 0.0002303  | 0.0002303  |   0.0 |  0.00
Modify  | 0.39303    | 0.39303    | 0.39303    |   0.0 |  0.38
Other   |            | 0.05844    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3116 ave        3116 max        3116 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118960 ave      118960 max      118960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118960
Ave neighs/atom = 59.48
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.900481710637, Press = 0.478710377780153
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    293000  -10444.14      -10444.14      -10521.335     -10521.335      298.75528      298.75528      28006.669      28006.669      1794.4503      1794.4503    
    294000  -10448.356     -10448.356     -10522.841     -10522.841      288.26235      288.26235      28077.036      28077.036     -2281.5264     -2281.5264    
Loop time of 104.264 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.962 hours/ns, 9.591 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    | 103.73     | 103.73     | 103.73     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08133    | 0.08133    | 0.08133    |   0.0 |  0.08
Output  | 0.00020106 | 0.00020106 | 0.00020106 |   0.0 |  0.00
Modify  | 0.38931    | 0.38931    | 0.38931    |   0.0 |  0.37
Other   |            | 0.05855    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3148 ave        3148 max        3148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119046 ave      119046 max      119046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119046
Ave neighs/atom = 59.523
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.899407062794, Press = 0.248733703515185
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    294000  -10448.356     -10448.356     -10522.841     -10522.841      288.26235      288.26235      28077.036      28077.036     -2281.5264     -2281.5264    
    295000  -10445.73      -10445.73      -10520.541     -10520.541      289.52804      289.52804      28031.669      28031.669      387.33236      387.33236    
Loop time of 105.193 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.220 hours/ns, 9.506 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    | 104.66     | 104.66     | 104.66     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08099    | 0.08099    | 0.08099    |   0.0 |  0.08
Output  | 0.00016657 | 0.00016657 | 0.00016657 |   0.0 |  0.00
Modify  | 0.3967     | 0.3967     | 0.3967     |   0.0 |  0.38
Other   |            | 0.05922    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3112 ave        3112 max        3112 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118782 ave      118782 max      118782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118782
Ave neighs/atom = 59.391
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.890295769523, Press = 0.116756025478545
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    295000  -10445.73      -10445.73      -10520.541     -10520.541      289.52804      289.52804      28031.669      28031.669      387.33236      387.33236    
    296000  -10441.276     -10441.276     -10518.416     -10518.416      298.54064      298.54064      28035.656      28035.656      563.62635      563.62635    
Loop time of 107.446 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.846 hours/ns, 9.307 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    | 106.9      | 106.9      | 106.9      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083085   | 0.083085   | 0.083085   |   0.0 |  0.08
Output  | 0.00016529 | 0.00016529 | 0.00016529 |   0.0 |  0.00
Modify  | 0.40704    | 0.40704    | 0.40704    |   0.0 |  0.38
Other   |            | 0.05994    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3146 ave        3146 max        3146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118946 ave      118946 max      118946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118946
Ave neighs/atom = 59.473
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.896404415878, Press = 0.309267452767255
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    296000  -10441.276     -10441.276     -10518.416     -10518.416      298.54064      298.54064      28035.656      28035.656      563.62635      563.62635    
    297000  -10446.176     -10446.176     -10521.37      -10521.37       291.00967      291.00967      28045.54       28045.54      -346.51705     -346.51705    
Loop time of 105.799 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.389 hours/ns, 9.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    | 105.26     | 105.26     | 105.26     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081846   | 0.081846   | 0.081846   |   0.0 |  0.08
Output  | 0.0001643  | 0.0001643  | 0.0001643  |   0.0 |  0.00
Modify  | 0.39833    | 0.39833    | 0.39833    |   0.0 |  0.38
Other   |            | 0.05925    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3132 ave        3132 max        3132 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119018 ave      119018 max      119018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119018
Ave neighs/atom = 59.509
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.904294246008, Press = 0.232400303739126
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    297000  -10446.176     -10446.176     -10521.37      -10521.37       291.00967      291.00967      28045.54       28045.54      -346.51705     -346.51705    
    298000  -10442.462     -10442.462     -10518.935     -10518.935      295.96035      295.96035      28043.05       28043.05       28.050531      28.050531    
Loop time of 103.03 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.620 hours/ns, 9.706 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    | 102.5      | 102.5      | 102.5      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081128   | 0.081128   | 0.081128   |   0.0 |  0.08
Output  | 0.00016657 | 0.00016657 | 0.00016657 |   0.0 |  0.00
Modify  | 0.38804    | 0.38804    | 0.38804    |   0.0 |  0.38
Other   |            | 0.05855    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3152 ave        3152 max        3152 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118944 ave      118944 max      118944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118944
Ave neighs/atom = 59.472
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.912043939548, Press = 0.218930725092138
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    298000  -10442.462     -10442.462     -10518.935     -10518.935      295.96035      295.96035      28043.05       28043.05       28.050531      28.050531    
    299000  -10449.781     -10449.781     -10523.804     -10523.804      286.47827      286.47827      28028.616      28028.616      211.99478      211.99478    
Loop time of 104.4 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 29.000 hours/ns, 9.579 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    | 103.87     | 103.87     | 103.87     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080992   | 0.080992   | 0.080992   |   0.0 |  0.08
Output  | 0.0001654  | 0.0001654  | 0.0001654  |   0.0 |  0.00
Modify  | 0.3928     | 0.3928     | 0.3928     |   0.0 |  0.38
Other   |            | 0.05875    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3123 ave        3123 max        3123 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118952 ave      118952 max      118952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118952
Ave neighs/atom = 59.476
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.908634896532, Press = 0.223914216009542
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    299000  -10449.781     -10449.781     -10523.804     -10523.804      286.47827      286.47827      28028.616      28028.616      211.99478      211.99478    
    300000  -10444.722     -10444.722     -10520.677     -10520.677      293.95384      293.95384      28046.179      28046.179     -233.87026     -233.87026    
Loop time of 104.354 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 28.987 hours/ns, 9.583 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    | 103.82     | 103.82     | 103.82     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082503   | 0.082503   | 0.082503   |   0.0 |  0.08
Output  | 0.00016393 | 0.00016393 | 0.00016393 |   0.0 |  0.00
Modify  | 0.39499    | 0.39499    | 0.39499    |   0.0 |  0.38
Other   |            | 0.05951    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3157 ave        3157 max        3157 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119006 ave      119006 max      119006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119006
Ave neighs/atom = 59.503
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.899648486445, Press = 0.294546445541417
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    300000  -10444.722     -10444.722     -10520.677     -10520.677      293.95384      293.95384      28046.179      28046.179     -233.87026     -233.87026    
    301000  -10444.783     -10444.783     -10519.012     -10519.012      287.27395      287.27395      28077.703      28077.703     -1870.316      -1870.316     
Loop time of 102.92 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.589 hours/ns, 9.716 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.39     | 102.39     | 102.39     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080185   | 0.080185   | 0.080185   |   0.0 |  0.08
Output  | 0.00016316 | 0.00016316 | 0.00016316 |   0.0 |  0.00
Modify  | 0.38674    | 0.38674    | 0.38674    |   0.0 |  0.38
Other   |            | 0.05838    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3119 ave        3119 max        3119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118938 ave      118938 max      118938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118938
Ave neighs/atom = 59.469
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.901037357369, Press = 0.0817435648007599
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    301000  -10444.783     -10444.783     -10519.012     -10519.012      287.27395      287.27395      28077.703      28077.703     -1870.316      -1870.316     
    302000  -10448.745     -10448.745     -10522.489     -10522.489      285.39881      285.39881      27986.704      27986.704      2866.4737      2866.4737    
Loop time of 103.386 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.718 hours/ns, 9.672 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    | 102.86     | 102.86     | 102.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080523   | 0.080523   | 0.080523   |   0.0 |  0.08
Output  | 0.00016388 | 0.00016388 | 0.00016388 |   0.0 |  0.00
Modify  | 0.38679    | 0.38679    | 0.38679    |   0.0 |  0.37
Other   |            | 0.05905    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3134 ave        3134 max        3134 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118860 ave      118860 max      118860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118860
Ave neighs/atom = 59.43
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.891539386617, Press = 0.115697206302692
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    302000  -10448.745     -10448.745     -10522.489     -10522.489      285.39881      285.39881      27986.704      27986.704      2866.4737      2866.4737    
    303000  -10444.741     -10444.741     -10521.689     -10521.689      297.79518      297.79518      28039.932      28039.932      34.121927      34.121927    
Loop time of 105.46 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.294 hours/ns, 9.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    | 104.92     | 104.92     | 104.92     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082333   | 0.082333   | 0.082333   |   0.0 |  0.08
Output  | 0.00019338 | 0.00019338 | 0.00019338 |   0.0 |  0.00
Modify  | 0.39636    | 0.39636    | 0.39636    |   0.0 |  0.38
Other   |            | 0.0588     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3172 ave        3172 max        3172 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119042 ave      119042 max      119042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119042
Ave neighs/atom = 59.521
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.890344467023, Press = 0.391989352531398
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    303000  -10444.741     -10444.741     -10521.689     -10521.689      297.79518      297.79518      28039.932      28039.932      34.121927      34.121927    
    304000  -10447.668     -10447.668     -10521.522     -10521.522      285.82065      285.82065      28059.372      28059.372     -1141.369      -1141.369     
Loop time of 103.627 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.785 hours/ns, 9.650 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    | 103.1      | 103.1      | 103.1      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080723   | 0.080723   | 0.080723   |   0.0 |  0.08
Output  | 0.00021058 | 0.00021058 | 0.00021058 |   0.0 |  0.00
Modify  | 0.38722    | 0.38722    | 0.38722    |   0.0 |  0.37
Other   |            | 0.05794    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3136 ave        3136 max        3136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118914 ave      118914 max      118914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118914
Ave neighs/atom = 59.457
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.881573763321, Press = 0.17471990848978
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    304000  -10447.668     -10447.668     -10521.522     -10521.522      285.82065      285.82065      28059.372      28059.372     -1141.369      -1141.369     
    305000  -10443.646     -10443.646     -10516.84      -10516.84       283.2708       283.2708       28027.919      28027.919      1052.9385      1052.9385    
Loop time of 105.233 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.231 hours/ns, 9.503 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    | 104.7      | 104.7      | 104.7      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081733   | 0.081733   | 0.081733   |   0.0 |  0.08
Output  | 0.00016376 | 0.00016376 | 0.00016376 |   0.0 |  0.00
Modify  | 0.39411    | 0.39411    | 0.39411    |   0.0 |  0.37
Other   |            | 0.05951    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3144 ave        3144 max        3144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118898 ave      118898 max      118898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118898
Ave neighs/atom = 59.449
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.882255075203, Press = 0.152604861390909
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    305000  -10443.646     -10443.646     -10516.84      -10516.84       283.2708       283.2708       28027.919      28027.919      1052.9385      1052.9385    
    306000  -10444.59      -10444.59      -10520.771     -10520.771      294.82841      294.82841      28042.621      28042.621     -17.53326      -17.53326     
Loop time of 104.935 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.149 hours/ns, 9.530 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    | 104.4      | 104.4      | 104.4      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081732   | 0.081732   | 0.081732   |   0.0 |  0.08
Output  | 0.00020889 | 0.00020889 | 0.00020889 |   0.0 |  0.00
Modify  | 0.39349    | 0.39349    | 0.39349    |   0.0 |  0.37
Other   |            | 0.05896    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3156 ave        3156 max        3156 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119038 ave      119038 max      119038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119038
Ave neighs/atom = 59.519
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.888013047804, Press = 0.285450550412379
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    306000  -10444.59      -10444.59      -10520.771     -10520.771      294.82841      294.82841      28042.621      28042.621     -17.53326      -17.53326     
    307000  -10446.011     -10446.011     -10521.741     -10521.741      293.08324      293.08324      28050.118      28050.118     -626.18546     -626.18546    
Loop time of 105.208 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.225 hours/ns, 9.505 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    | 104.67     | 104.67     | 104.67     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082328   | 0.082328   | 0.082328   |   0.0 |  0.08
Output  | 0.00016335 | 0.00016335 | 0.00016335 |   0.0 |  0.00
Modify  | 0.39701    | 0.39701    | 0.39701    |   0.0 |  0.38
Other   |            | 0.05917    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3142 ave        3142 max        3142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118920 ave      118920 max      118920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118920
Ave neighs/atom = 59.46
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.897964220653, Press = 0.16225229507639
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    307000  -10446.011     -10446.011     -10521.741     -10521.741      293.08324      293.08324      28050.118      28050.118     -626.18546     -626.18546    
    308000  -10441.579     -10441.579     -10516.76      -10516.76       290.95633      290.95633      28027.971      28027.971      1098.0423      1098.0423    
Loop time of 105.696 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.360 hours/ns, 9.461 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    | 105.16     | 105.16     | 105.16     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082248   | 0.082248   | 0.082248   |   0.0 |  0.08
Output  | 0.00016544 | 0.00016544 | 0.00016544 |   0.0 |  0.00
Modify  | 0.39766    | 0.39766    | 0.39766    |   0.0 |  0.38
Other   |            | 0.05939    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3135 ave        3135 max        3135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118888 ave      118888 max      118888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118888
Ave neighs/atom = 59.444
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.900589847364, Press = 0.206352552560905
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    308000  -10441.579     -10441.579     -10516.76      -10516.76       290.95633      290.95633      28027.971      28027.971      1098.0423      1098.0423    
    309000  -10442.587     -10442.587     -10518.538     -10518.538      293.93795      293.93795      28058.626      28058.626     -781.31855     -781.31855    
Loop time of 105.395 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.276 hours/ns, 9.488 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    | 104.86     | 104.86     | 104.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081705   | 0.081705   | 0.081705   |   0.0 |  0.08
Output  | 0.00025372 | 0.00025372 | 0.00025372 |   0.0 |  0.00
Modify  | 0.39624    | 0.39624    | 0.39624    |   0.0 |  0.38
Other   |            | 0.05897    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3141 ave        3141 max        3141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119008 ave      119008 max      119008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119008
Ave neighs/atom = 59.504
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.905672931007, Press = 0.300433608957712
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    309000  -10442.587     -10442.587     -10518.538     -10518.538      293.93795      293.93795      28058.626      28058.626     -781.31855     -781.31855    
    310000  -10444.796     -10444.796     -10519.838     -10519.838      290.42003      290.42003      28066.181      28066.181     -1320.0524     -1320.0524    
Loop time of 104.833 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.120 hours/ns, 9.539 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    | 104.3      | 104.3      | 104.3      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081298   | 0.081298   | 0.081298   |   0.0 |  0.08
Output  | 0.00016381 | 0.00016381 | 0.00016381 |   0.0 |  0.00
Modify  | 0.39431    | 0.39431    | 0.39431    |   0.0 |  0.38
Other   |            | 0.05877    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3142 ave        3142 max        3142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118990 ave      118990 max      118990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118990
Ave neighs/atom = 59.495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.906108401597, Press = -0.0149933340424888
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    310000  -10444.796     -10444.796     -10519.838     -10519.838      290.42003      290.42003      28066.181      28066.181     -1320.0524     -1320.0524    
    311000  -10445.826     -10445.826     -10520.515     -10520.515      289.05369      289.05369      27991.467      27991.467      2651.9483      2651.9483    
Loop time of 105.153 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.209 hours/ns, 9.510 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    | 104.61     | 104.61     | 104.61     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081391   | 0.081391   | 0.081391   |   0.0 |  0.08
Output  | 0.00021098 | 0.00021098 | 0.00021098 |   0.0 |  0.00
Modify  | 0.39776    | 0.39776    | 0.39776    |   0.0 |  0.38
Other   |            | 0.05911    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3129 ave        3129 max        3129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118920 ave      118920 max      118920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118920
Ave neighs/atom = 59.46
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.910913425988, Press = 0.237385816678238
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    311000  -10445.826     -10445.826     -10520.515     -10520.515      289.05369      289.05369      27991.467      27991.467      2651.9483      2651.9483    
    312000  -10440.131     -10440.131     -10516.6       -10516.6        295.94228      295.94228      28063.623      28063.623     -842.84972     -842.84972    
Loop time of 103.153 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.838 ns/day, 28.654 hours/ns, 9.694 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    | 102.63     | 102.63     | 102.63     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080542   | 0.080542   | 0.080542   |   0.0 |  0.08
Output  | 0.00016492 | 0.00016492 | 0.00016492 |   0.0 |  0.00
Modify  | 0.38591    | 0.38591    | 0.38591    |   0.0 |  0.37
Other   |            | 0.05813    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3145 ave        3145 max        3145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119102 ave      119102 max      119102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119102
Ave neighs/atom = 59.551
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.917897224762, Press = 0.302097867571567
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    312000  -10440.131     -10440.131     -10516.6       -10516.6        295.94228      295.94228      28063.623      28063.623     -842.84972     -842.84972    
    313000  -10445.212     -10445.212     -10521.124     -10521.124      293.78726      293.78726      28042.917      28042.917     -267.29369     -267.29369    
Loop time of 105.11 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.197 hours/ns, 9.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    | 104.57     | 104.57     | 104.57     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081661   | 0.081661   | 0.081661   |   0.0 |  0.08
Output  | 0.00023317 | 0.00023317 | 0.00023317 |   0.0 |  0.00
Modify  | 0.39696    | 0.39696    | 0.39696    |   0.0 |  0.38
Other   |            | 0.05899    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3144 ave        3144 max        3144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118976 ave      118976 max      118976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118976
Ave neighs/atom = 59.488
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.921013155519, Press = 0.141642523731701
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    313000  -10445.212     -10445.212     -10521.124     -10521.124      293.78726      293.78726      28042.917      28042.917     -267.29369     -267.29369    
    314000  -10443.465     -10443.465     -10519.002     -10519.002      292.33704      292.33704      28038.254      28038.254      373.77421      373.77421    
Loop time of 102.917 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.840 ns/day, 28.588 hours/ns, 9.717 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    | 102.39     | 102.39     | 102.39     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080215   | 0.080215   | 0.080215   |   0.0 |  0.08
Output  | 0.00020065 | 0.00020065 | 0.00020065 |   0.0 |  0.00
Modify  | 0.38744    | 0.38744    | 0.38744    |   0.0 |  0.38
Other   |            | 0.05844    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3125 ave        3125 max        3125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118902 ave      118902 max      118902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118902
Ave neighs/atom = 59.451
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.926425637019, Press = 0.215646944203583
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    314000  -10443.465     -10443.465     -10519.002     -10519.002      292.33704      292.33704      28038.254      28038.254      373.77421      373.77421    
    315000  -10446.187     -10446.187     -10520.973     -10520.973      289.43079      289.43079      28053.737      28053.737     -668.70419     -668.70419    
Loop time of 103.516 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.835 ns/day, 28.754 hours/ns, 9.660 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    | 102.99     | 102.99     | 102.99     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080442   | 0.080442   | 0.080442   |   0.0 |  0.08
Output  | 0.00020938 | 0.00020938 | 0.00020938 |   0.0 |  0.00
Modify  | 0.3882     | 0.3882     | 0.3882     |   0.0 |  0.38
Other   |            | 0.05866    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3132 ave        3132 max        3132 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119062 ave      119062 max      119062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119062
Ave neighs/atom = 59.531
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.924067222624, Press = 0.167001688975541
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    315000  -10446.187     -10446.187     -10520.973     -10520.973      289.43079      289.43079      28053.737      28053.737     -668.70419     -668.70419    
    316000  -10445.136     -10445.136     -10520.072     -10520.072      290.00995      290.00995      28030.203      28030.203      651.14545      651.14545    
Loop time of 104.105 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.918 hours/ns, 9.606 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    | 103.57     | 103.57     | 103.57     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080622   | 0.080622   | 0.080622   |   0.0 |  0.08
Output  | 0.0001652  | 0.0001652  | 0.0001652  |   0.0 |  0.00
Modify  | 0.39085    | 0.39085    | 0.39085    |   0.0 |  0.38
Other   |            | 0.0586     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3117 ave        3117 max        3117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118932 ave      118932 max      118932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118932
Ave neighs/atom = 59.466
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.923849920635, Press = 0.0649214544499269
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    316000  -10445.136     -10445.136     -10520.072     -10520.072      290.00995      290.00995      28030.203      28030.203      651.14545      651.14545    
    317000  -10446.012     -10446.012     -10521.291     -10521.291      291.33742      291.33742      28027.013      28027.013      761.05045      761.05045    
Loop time of 104.477 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.022 hours/ns, 9.571 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.94     | 103.94     | 103.94     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081437   | 0.081437   | 0.081437   |   0.0 |  0.08
Output  | 0.00020584 | 0.00020584 | 0.00020584 |   0.0 |  0.00
Modify  | 0.39488    | 0.39488    | 0.39488    |   0.0 |  0.38
Other   |            | 0.05878    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3133 ave        3133 max        3133 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119038 ave      119038 max      119038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119038
Ave neighs/atom = 59.519
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.914421504099, Press = 0.334019247354224
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    317000  -10446.012     -10446.012     -10521.291     -10521.291      291.33742      291.33742      28027.013      28027.013      761.05045      761.05045    
    318000  -10445.915     -10445.915     -10522.334     -10522.334      295.74887      295.74887      28082.486      28082.486     -2347.7712     -2347.7712    
Loop time of 104.375 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 28.993 hours/ns, 9.581 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    | 103.84     | 103.84     | 103.84     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082332   | 0.082332   | 0.082332   |   0.0 |  0.08
Output  | 0.00050259 | 0.00050259 | 0.00050259 |   0.0 |  0.00
Modify  | 0.39639    | 0.39639    | 0.39639    |   0.0 |  0.38
Other   |            | 0.05936    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3167 ave        3167 max        3167 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118890 ave      118890 max      118890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118890
Ave neighs/atom = 59.445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.914589541419, Press = 0.126476154177974
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    318000  -10445.915     -10445.915     -10522.334     -10522.334      295.74887      295.74887      28082.486      28082.486     -2347.7712     -2347.7712    
    319000  -10443.546     -10443.546     -10518.968     -10518.968      291.88767      291.88767      28016.933      28016.933      1533.3816      1533.3816    
Loop time of 103.55 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.764 hours/ns, 9.657 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    | 103.02     | 103.02     | 103.02     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080127   | 0.080127   | 0.080127   |   0.0 |  0.08
Output  | 0.00016544 | 0.00016544 | 0.00016544 |   0.0 |  0.00
Modify  | 0.38689    | 0.38689    | 0.38689    |   0.0 |  0.37
Other   |            | 0.05854    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3098 ave        3098 max        3098 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118834 ave      118834 max      118834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118834
Ave neighs/atom = 59.417
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.909457122964, Press = 0.0568041042358219
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    319000  -10443.546     -10443.546     -10518.968     -10518.968      291.88767      291.88767      28016.933      28016.933      1533.3816      1533.3816    
    320000  -10446.815     -10446.815     -10521.136     -10521.136      287.63355      287.63355      28030.569      28030.569      595.22389      595.22389    
Loop time of 106.621 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.617 hours/ns, 9.379 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.07     | 106.07     | 106.07     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084514   | 0.084514   | 0.084514   |   0.0 |  0.08
Output  | 0.00016366 | 0.00016366 | 0.00016366 |   0.0 |  0.00
Modify  | 0.40378    | 0.40378    | 0.40378    |   0.0 |  0.38
Other   |            | 0.05958    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3202 ave        3202 max        3202 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118994 ave      118994 max      118994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118994
Ave neighs/atom = 59.497
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.909818084091, Press = 0.315300456190946
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    320000  -10446.815     -10446.815     -10521.136     -10521.136      287.63355      287.63355      28030.569      28030.569      595.22389      595.22389    
    321000  -10445.583     -10445.583     -10520.139     -10520.139      288.54024      288.54024      28070.761      28070.761     -1615.7687     -1615.7687    
Loop time of 103.614 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.782 hours/ns, 9.651 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    | 103.09     | 103.09     | 103.09     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081027   | 0.081027   | 0.081027   |   0.0 |  0.08
Output  | 0.00016402 | 0.00016402 | 0.00016402 |   0.0 |  0.00
Modify  | 0.38854    | 0.38854    | 0.38854    |   0.0 |  0.37
Other   |            | 0.05845    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3111 ave        3111 max        3111 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119034 ave      119034 max      119034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119034
Ave neighs/atom = 59.517
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.903182493335, Press = 0.120148619553828
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    321000  -10445.583     -10445.583     -10520.139     -10520.139      288.54024      288.54024      28070.761      28070.761     -1615.7687     -1615.7687    
    322000  -10443.799     -10443.799     -10520.081     -10520.081      295.21987      295.21987      28015.835      28015.835      1565.1484      1565.1484    
Loop time of 103.563 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.767 hours/ns, 9.656 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    | 103.03     | 103.03     | 103.03     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080811   | 0.080811   | 0.080811   |   0.0 |  0.08
Output  | 0.0001664  | 0.0001664  | 0.0001664  |   0.0 |  0.00
Modify  | 0.39013    | 0.39013    | 0.39013    |   0.0 |  0.38
Other   |            | 0.05836    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3143 ave        3143 max        3143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118888 ave      118888 max      118888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118888
Ave neighs/atom = 59.444
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.899693999192, Press = 0.0992309309482534
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    322000  -10443.799     -10443.799     -10520.081     -10520.081      295.21987      295.21987      28015.835      28015.835      1565.1484      1565.1484    
    323000  -10444.918     -10444.918     -10520.827     -10520.827      293.77631      293.77631      28036.365      28036.365      213.10773      213.10773    
Loop time of 104.733 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.093 hours/ns, 9.548 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    | 104.2      | 104.2      | 104.2      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081914   | 0.081914   | 0.081914   |   0.0 |  0.08
Output  | 0.00016324 | 0.00016324 | 0.00016324 |   0.0 |  0.00
Modify  | 0.39566    | 0.39566    | 0.39566    |   0.0 |  0.38
Other   |            | 0.05896    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3148 ave        3148 max        3148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118958 ave      118958 max      118958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118958
Ave neighs/atom = 59.479
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.892429506394, Press = 0.396740605818689
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    323000  -10444.918     -10444.918     -10520.827     -10520.827      293.77631      293.77631      28036.365      28036.365      213.10773      213.10773    
    324000  -10443.122     -10443.122     -10519.862     -10519.862      296.99091      296.99091      28100.962      28100.962     -3159.1759     -3159.1759    
Loop time of 103.44 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.835 ns/day, 28.733 hours/ns, 9.667 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.92     | 102.92     | 102.92     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080177   | 0.080177   | 0.080177   |   0.0 |  0.08
Output  | 0.00019731 | 0.00019731 | 0.00019731 |   0.0 |  0.00
Modify  | 0.38461    | 0.38461    | 0.38461    |   0.0 |  0.37
Other   |            | 0.05908    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3143 ave        3143 max        3143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118938 ave      118938 max      118938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118938
Ave neighs/atom = 59.469
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.888590769006, Press = 0.062679761151373
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    324000  -10443.122     -10443.122     -10519.862     -10519.862      296.99091      296.99091      28100.962      28100.962     -3159.1759     -3159.1759    
    325000  -10447.904     -10447.904     -10520.969     -10520.969      282.76933      282.76933      28007.471      28007.471      1765.26        1765.26      
Loop time of 104.058 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.905 hours/ns, 9.610 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    | 103.53     | 103.53     | 103.53     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081021   | 0.081021   | 0.081021   |   0.0 |  0.08
Output  | 0.00016469 | 0.00016469 | 0.00016469 |   0.0 |  0.00
Modify  | 0.39252    | 0.39252    | 0.39252    |   0.0 |  0.38
Other   |            | 0.05865    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3125 ave        3125 max        3125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118804 ave      118804 max      118804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118804
Ave neighs/atom = 59.402
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.882492959585, Press = 0.110225098221175
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    325000  -10447.904     -10447.904     -10520.969     -10520.969      282.76933      282.76933      28007.471      28007.471      1765.26        1765.26      
    326000  -10443.536     -10443.536     -10519.941     -10519.941      295.69312      295.69312      28041.441      28041.441      15.716741      15.716741    
Loop time of 103.679 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.800 hours/ns, 9.645 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    | 103.15     | 103.15     | 103.15     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081521   | 0.081521   | 0.081521   |   0.0 |  0.08
Output  | 0.00021057 | 0.00021057 | 0.00021057 |   0.0 |  0.00
Modify  | 0.39064    | 0.39064    | 0.39064    |   0.0 |  0.38
Other   |            | 0.05871    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3162 ave        3162 max        3162 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118976 ave      118976 max      118976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118976
Ave neighs/atom = 59.488
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.879059472918, Press = 0.252247234056113
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    326000  -10443.536     -10443.536     -10519.941     -10519.941      295.69312      295.69312      28041.441      28041.441      15.716741      15.716741    
    327000  -10447.351     -10447.351     -10522.249     -10522.249      289.8648       289.8648       28049.82       28049.82      -930.32365     -930.32365    
Loop time of 104.409 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 29.002 hours/ns, 9.578 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    | 103.87     | 103.87     | 103.87     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081519   | 0.081519   | 0.081519   |   0.0 |  0.08
Output  | 0.00016418 | 0.00016418 | 0.00016418 |   0.0 |  0.00
Modify  | 0.39283    | 0.39283    | 0.39283    |   0.0 |  0.38
Other   |            | 0.05941    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3135 ave        3135 max        3135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118930 ave      118930 max      118930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118930
Ave neighs/atom = 59.465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.878213307706, Press = 0.130037447929604
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    327000  -10447.351     -10447.351     -10522.249     -10522.249      289.8648       289.8648       28049.82       28049.82      -930.32365     -930.32365    
    328000  -10443.97      -10443.97      -10518.947     -10518.947      290.16834      290.16834      28025.521      28025.521      964.48366      964.48366    
Loop time of 105.042 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.178 hours/ns, 9.520 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    | 104.51     | 104.51     | 104.51     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081017   | 0.081017   | 0.081017   |   0.0 |  0.08
Output  | 0.00016361 | 0.00016361 | 0.00016361 |   0.0 |  0.00
Modify  | 0.39443    | 0.39443    | 0.39443    |   0.0 |  0.38
Other   |            | 0.05908    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3105 ave        3105 max        3105 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118924 ave      118924 max      118924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118924
Ave neighs/atom = 59.462
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.87408788874, Press = 0.168820944441177
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    328000  -10443.97      -10443.97      -10518.947     -10518.947      290.16834      290.16834      28025.521      28025.521      964.48366      964.48366    
    329000  -10441.862     -10441.862     -10518.2       -10518.2        295.43433      295.43433      28063.795      28063.795     -968.98863     -968.98863    
Loop time of 104.157 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.932 hours/ns, 9.601 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.63     | 103.63     | 103.63     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080883   | 0.080883   | 0.080883   |   0.0 |  0.08
Output  | 0.00024835 | 0.00024835 | 0.00024835 |   0.0 |  0.00
Modify  | 0.39005    | 0.39005    | 0.39005    |   0.0 |  0.37
Other   |            | 0.05879    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3153 ave        3153 max        3153 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119022 ave      119022 max      119022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119022
Ave neighs/atom = 59.511
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.883435582735, Press = 0.283328404464852
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    329000  -10441.862     -10441.862     -10518.2       -10518.2        295.43433      295.43433      28063.795      28063.795     -968.98863     -968.98863    
    330000  -10444.942     -10444.942     -10521.826     -10521.826      297.54939      297.54939      28066.992      28066.992     -1380.7062     -1380.7062    
Loop time of 104.872 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.131 hours/ns, 9.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    | 104.34     | 104.34     | 104.34     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081556   | 0.081556   | 0.081556   |   0.0 |  0.08
Output  | 0.00016423 | 0.00016423 | 0.00016423 |   0.0 |  0.00
Modify  | 0.39601    | 0.39601    | 0.39601    |   0.0 |  0.38
Other   |            | 0.05915    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3141 ave        3141 max        3141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118946 ave      118946 max      118946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118946
Ave neighs/atom = 59.473
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.887557551642, Press = 0.0174460391750716
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    330000  -10444.942     -10444.942     -10521.826     -10521.826      297.54939      297.54939      28066.992      28066.992     -1380.7062     -1380.7062    
    331000  -10441.59      -10441.59      -10519.063     -10519.063      299.82969      299.82969      28006.323      28006.323      2242.7411      2242.7411    
Loop time of 104.051 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.903 hours/ns, 9.611 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    | 103.52     | 103.52     | 103.52     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080346   | 0.080346   | 0.080346   |   0.0 |  0.08
Output  | 0.00016523 | 0.00016523 | 0.00016523 |   0.0 |  0.00
Modify  | 0.39178    | 0.39178    | 0.39178    |   0.0 |  0.38
Other   |            | 0.05837    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3113 ave        3113 max        3113 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118856 ave      118856 max      118856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118856
Ave neighs/atom = 59.428
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.89673365809, Press = 0.16154717526406
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    331000  -10441.59      -10441.59      -10519.063     -10519.063      299.82969      299.82969      28006.323      28006.323      2242.7411      2242.7411    
    332000  -10443.055     -10443.055     -10520.134     -10520.134      298.30433      298.30433      28059.13       28059.13      -832.4151      -832.4151     
Loop time of 102.455 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.843 ns/day, 28.460 hours/ns, 9.760 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.93     | 101.93     | 101.93     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080915   | 0.080915   | 0.080915   |   0.0 |  0.08
Output  | 0.00016537 | 0.00016537 | 0.00016537 |   0.0 |  0.00
Modify  | 0.3845     | 0.3845     | 0.3845     |   0.0 |  0.38
Other   |            | 0.0583     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3177 ave        3177 max        3177 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119050 ave      119050 max      119050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119050
Ave neighs/atom = 59.525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.895514627427, Press = 0.304605317594033
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    332000  -10443.055     -10443.055     -10520.134     -10520.134      298.30433      298.30433      28059.13       28059.13      -832.4151      -832.4151     
    333000  -10445.204     -10445.204     -10519.465     -10519.465      287.39874      287.39874      28060.171      28060.171     -1055.0779     -1055.0779    
Loop time of 101.656 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.850 ns/day, 28.238 hours/ns, 9.837 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    | 101.14     | 101.14     | 101.14     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080188   | 0.080188   | 0.080188   |   0.0 |  0.08
Output  | 0.00016518 | 0.00016518 | 0.00016518 |   0.0 |  0.00
Modify  | 0.37885    | 0.37885    | 0.37885    |   0.0 |  0.37
Other   |            | 0.05857    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3161 ave        3161 max        3161 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118898 ave      118898 max      118898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118898
Ave neighs/atom = 59.449
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.894073043093, Press = 0.0514024300088988
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    333000  -10445.204     -10445.204     -10519.465     -10519.465      287.39874      287.39874      28060.171      28060.171     -1055.0779     -1055.0779    
    334000  -10445.684     -10445.684     -10521.239     -10521.239      292.40358      292.40358      27999.447      27999.447      2364.176       2364.176     
Loop time of 103.555 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.765 hours/ns, 9.657 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    | 103.03     | 103.03     | 103.03     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081418   | 0.081418   | 0.081418   |   0.0 |  0.08
Output  | 0.00023034 | 0.00023034 | 0.00023034 |   0.0 |  0.00
Modify  | 0.38829    | 0.38829    | 0.38829    |   0.0 |  0.37
Other   |            | 0.05864    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3149 ave        3149 max        3149 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118932 ave      118932 max      118932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118932
Ave neighs/atom = 59.466
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.894810366717, Press = 0.181193673520461
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    334000  -10445.684     -10445.684     -10521.239     -10521.239      292.40358      292.40358      27999.447      27999.447      2364.176       2364.176     
    335000  -10440.826     -10440.826     -10518.048     -10518.048      298.85598      298.85598      28069.652      28069.652     -1330.5858     -1330.5858    
Loop time of 104.196 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.943 hours/ns, 9.597 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.66     | 103.66     | 103.66     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081188   | 0.081188   | 0.081188   |   0.0 |  0.08
Output  | 0.00022663 | 0.00022663 | 0.00022663 |   0.0 |  0.00
Modify  | 0.39195    | 0.39195    | 0.39195    |   0.0 |  0.38
Other   |            | 0.05922    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3125 ave        3125 max        3125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118982 ave      118982 max      118982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118982
Ave neighs/atom = 59.491
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.899106722981, Press = 0.397939762074715
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    335000  -10440.826     -10440.826     -10518.048     -10518.048      298.85598      298.85598      28069.652      28069.652     -1330.5858     -1330.5858    
    336000  -10446.06      -10446.06      -10519.894     -10519.894      285.74391      285.74391      28070.813      28070.813     -1617.7944     -1617.7944    
Loop time of 105.709 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.364 hours/ns, 9.460 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    | 105.17     | 105.17     | 105.17     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080968   | 0.080968   | 0.080968   |   0.0 |  0.08
Output  | 0.00020298 | 0.00020298 | 0.00020298 |   0.0 |  0.00
Modify  | 0.39973    | 0.39973    | 0.39973    |   0.0 |  0.38
Other   |            | 0.05919    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3098 ave        3098 max        3098 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118946 ave      118946 max      118946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118946
Ave neighs/atom = 59.473
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.906701948678, Press = -0.0185520605273572
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    336000  -10446.06      -10446.06      -10519.894     -10519.894      285.74391      285.74391      28070.813      28070.813     -1617.7944     -1617.7944    
    337000  -10440.881     -10440.881     -10518.836     -10518.836      301.69411      301.69411      28025.185      28025.185      1217.8621      1217.8621    
Loop time of 105.455 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.293 hours/ns, 9.483 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    | 104.91     | 104.91     | 104.91     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081791   | 0.081791   | 0.081791   |   0.0 |  0.08
Output  | 0.00016496 | 0.00016496 | 0.00016496 |   0.0 |  0.00
Modify  | 0.39971    | 0.39971    | 0.39971    |   0.0 |  0.38
Other   |            | 0.0591     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3119 ave        3119 max        3119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118930 ave      118930 max      118930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118930
Ave neighs/atom = 59.465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.907669518783, Press = 0.177129561845012
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    337000  -10440.881     -10440.881     -10518.836     -10518.836      301.69411      301.69411      28025.185      28025.185      1217.8621      1217.8621    
    338000  -10445.314     -10445.314     -10521.94      -10521.94       296.54958      296.54958      28042.807      28042.807     -280.32014     -280.32014    
Loop time of 102.148 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.846 ns/day, 28.375 hours/ns, 9.790 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    | 101.63     | 101.63     | 101.63     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078603   | 0.078603   | 0.078603   |   0.0 |  0.08
Output  | 0.00019653 | 0.00019653 | 0.00019653 |   0.0 |  0.00
Modify  | 0.38011    | 0.38011    | 0.38011    |   0.0 |  0.37
Other   |            | 0.0581     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3088 ave        3088 max        3088 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119062 ave      119062 max      119062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119062
Ave neighs/atom = 59.531
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.916336291377, Press = 0.250877211871852
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    338000  -10445.314     -10445.314     -10521.94      -10521.94       296.54958      296.54958      28042.807      28042.807     -280.32014     -280.32014    
    339000  -10442.789     -10442.789     -10519.572     -10519.572      297.15694      297.15694      28065.374      28065.374     -1086.568      -1086.568     
Loop time of 104.786 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.107 hours/ns, 9.543 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    | 104.25     | 104.25     | 104.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081497   | 0.081497   | 0.081497   |   0.0 |  0.08
Output  | 0.00017061 | 0.00017061 | 0.00017061 |   0.0 |  0.00
Modify  | 0.39443    | 0.39443    | 0.39443    |   0.0 |  0.38
Other   |            | 0.0593     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3135 ave        3135 max        3135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118882 ave      118882 max      118882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118882
Ave neighs/atom = 59.441
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.914911538321, Press = 0.0916163318536163
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    339000  -10442.789     -10442.789     -10519.572     -10519.572      297.15694      297.15694      28065.374      28065.374     -1086.568      -1086.568     
    340000  -10447.598     -10447.598     -10522.283     -10522.283      289.03777      289.03777      28000.149      28000.149      1979.4422      1979.4422    
Loop time of 103.777 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.827 hours/ns, 9.636 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    | 103.25     | 103.25     | 103.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081162   | 0.081162   | 0.081162   |   0.0 |  0.08
Output  | 0.00016478 | 0.00016478 | 0.00016478 |   0.0 |  0.00
Modify  | 0.38728    | 0.38728    | 0.38728    |   0.0 |  0.37
Other   |            | 0.05796    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3162 ave        3162 max        3162 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118958 ave      118958 max      118958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118958
Ave neighs/atom = 59.479
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.910932880509, Press = 0.106045539994927
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    340000  -10447.598     -10447.598     -10522.283     -10522.283      289.03777      289.03777      28000.149      28000.149      1979.4422      1979.4422    
    341000  -10443.744     -10443.744     -10520.714     -10520.714      297.88312      297.88312      28043.091      28043.091     -158.92923     -158.92923    
Loop time of 102.917 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.840 ns/day, 28.588 hours/ns, 9.717 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    | 102.39     | 102.39     | 102.39     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081479   | 0.081479   | 0.081479   |   0.0 |  0.08
Output  | 0.00016604 | 0.00016604 | 0.00016604 |   0.0 |  0.00
Modify  | 0.38777    | 0.38777    | 0.38777    |   0.0 |  0.38
Other   |            | 0.05873    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3148 ave        3148 max        3148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119012 ave      119012 max      119012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119012
Ave neighs/atom = 59.506
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.904580492689, Press = 0.468866790040378
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    341000  -10443.744     -10443.744     -10520.714     -10520.714      297.88312      297.88312      28043.091      28043.091     -158.92923     -158.92923    
    342000  -10445.075     -10445.075     -10520.45      -10520.45       291.71007      291.71007      28102.186      28102.186     -3400.7892     -3400.7892    
Loop time of 104.665 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.074 hours/ns, 9.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    | 104.13     | 104.13     | 104.13     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08184    | 0.08184    | 0.08184    |   0.0 |  0.08
Output  | 0.00016508 | 0.00016508 | 0.00016508 |   0.0 |  0.00
Modify  | 0.3929     | 0.3929     | 0.3929     |   0.0 |  0.38
Other   |            | 0.0592     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3168 ave        3168 max        3168 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119008 ave      119008 max      119008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119008
Ave neighs/atom = 59.504
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.90613413127, Press = 0.0462990329931948
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    342000  -10445.075     -10445.075     -10520.45      -10520.45       291.71007      291.71007      28102.186      28102.186     -3400.7892     -3400.7892    
    343000  -10440.496     -10440.496     -10517.975     -10517.975      299.85272      299.85272      28029.964      28029.964      974.69654      974.69654    
Loop time of 103.804 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.834 hours/ns, 9.634 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    | 103.27     | 103.27     | 103.27     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081611   | 0.081611   | 0.081611   |   0.0 |  0.08
Output  | 0.00016491 | 0.00016491 | 0.00016491 |   0.0 |  0.00
Modify  | 0.39135    | 0.39135    | 0.39135    |   0.0 |  0.38
Other   |            | 0.05875    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3152 ave        3152 max        3152 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118834 ave      118834 max      118834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118834
Ave neighs/atom = 59.417
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.913690573573, Press = 0.126103508244843
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    343000  -10440.496     -10440.496     -10517.975     -10517.975      299.85272      299.85272      28029.964      28029.964      974.69654      974.69654    
    344000  -10445.851     -10445.851     -10520.198     -10520.198      287.73081      287.73081      28033.697      28033.697      353.5348       353.5348     
Loop time of 101.781 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.849 ns/day, 28.273 hours/ns, 9.825 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    | 101.26     | 101.26     | 101.26     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080634   | 0.080634   | 0.080634   |   0.0 |  0.08
Output  | 0.00016511 | 0.00016511 | 0.00016511 |   0.0 |  0.00
Modify  | 0.38247    | 0.38247    | 0.38247    |   0.0 |  0.38
Other   |            | 0.05802    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3165 ave        3165 max        3165 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118984 ave      118984 max      118984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118984
Ave neighs/atom = 59.492
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.917084303201, Press = 0.305666841203
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    344000  -10445.851     -10445.851     -10520.198     -10520.198      287.73081      287.73081      28033.697      28033.697      353.5348       353.5348     
    345000  -10442.253     -10442.253     -10517.846     -10517.846      292.55127      292.55127      28077.376      28077.376     -1799.043      -1799.043     
Loop time of 104.358 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 28.988 hours/ns, 9.582 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    | 103.83     | 103.83     | 103.83     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08154    | 0.08154    | 0.08154    |   0.0 |  0.08
Output  | 0.00016382 | 0.00016382 | 0.00016382 |   0.0 |  0.00
Modify  | 0.39045    | 0.39045    | 0.39045    |   0.0 |  0.37
Other   |            | 0.0587     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3143 ave        3143 max        3143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118972 ave      118972 max      118972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118972
Ave neighs/atom = 59.486
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.923639473226, Press = 0.135965417289961
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    345000  -10442.253     -10442.253     -10517.846     -10517.846      292.55127      292.55127      28077.376      28077.376     -1799.043      -1799.043     
    346000  -10446.266     -10446.266     -10520.951     -10520.951      289.03814      289.03814      28007.657      28007.657      1782.4552      1782.4552    
Loop time of 103.765 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.824 hours/ns, 9.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    | 103.24     | 103.24     | 103.24     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080962   | 0.080962   | 0.080962   |   0.0 |  0.08
Output  | 0.00016438 | 0.00016438 | 0.00016438 |   0.0 |  0.00
Modify  | 0.38956    | 0.38956    | 0.38956    |   0.0 |  0.38
Other   |            | 0.05917    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3089 ave        3089 max        3089 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118928 ave      118928 max      118928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118928
Ave neighs/atom = 59.464
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.929809380417, Press = 0.0397221736707744
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    346000  -10446.266     -10446.266     -10520.951     -10520.951      289.03814      289.03814      28007.657      28007.657      1782.4552      1782.4552    
    347000  -10441.703     -10441.703     -10518.898     -10518.898      298.75222      298.75222      28015.559      28015.559      1654.5522      1654.5522    
Loop time of 102.817 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.840 ns/day, 28.560 hours/ns, 9.726 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    | 102.29     | 102.29     | 102.29     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079833   | 0.079833   | 0.079833   |   0.0 |  0.08
Output  | 0.00016709 | 0.00016709 | 0.00016709 |   0.0 |  0.00
Modify  | 0.38458    | 0.38458    | 0.38458    |   0.0 |  0.37
Other   |            | 0.05842    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3114 ave        3114 max        3114 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119100 ave      119100 max      119100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119100
Ave neighs/atom = 59.55
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.933320727159, Press = 0.46697545643
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    347000  -10441.703     -10441.703     -10518.898     -10518.898      298.75222      298.75222      28015.559      28015.559      1654.5522      1654.5522    
    348000  -10445.806     -10445.806     -10519.939     -10519.939      286.90546      286.90546      28071.196      28071.196     -1613.61       -1613.61      
Loop time of 103.654 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.793 hours/ns, 9.647 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    | 103.13     | 103.13     | 103.13     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079528   | 0.079528   | 0.079528   |   0.0 |  0.08
Output  | 0.00016712 | 0.00016712 | 0.00016712 |   0.0 |  0.00
Modify  | 0.38677    | 0.38677    | 0.38677    |   0.0 |  0.37
Other   |            | 0.05852    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3091 ave        3091 max        3091 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118976 ave      118976 max      118976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118976
Ave neighs/atom = 59.488
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.933633825441, Press = 0.167014973058625
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    348000  -10445.806     -10445.806     -10519.939     -10519.939      286.90546      286.90546      28071.196      28071.196     -1613.61       -1613.61      
    349000  -10444.824     -10444.824     -10520.066     -10520.066      291.19286      291.19286      28028.681      28028.681      621.15616      621.15616    
Loop time of 102.368 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.844 ns/day, 28.436 hours/ns, 9.769 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    | 101.85     | 101.85     | 101.85     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080435   | 0.080435   | 0.080435   |   0.0 |  0.08
Output  | 0.00016442 | 0.00016442 | 0.00016442 |   0.0 |  0.00
Modify  | 0.38278    | 0.38278    | 0.38278    |   0.0 |  0.37
Other   |            | 0.05845    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3147 ave        3147 max        3147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118854 ave      118854 max      118854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118854
Ave neighs/atom = 59.427
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.941052287589, Press = 0.118855296193972
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    349000  -10444.824     -10444.824     -10520.066     -10520.066      291.19286      291.19286      28028.681      28028.681      621.15616      621.15616    
    350000  -10442.544     -10442.544     -10518.585     -10518.585      294.28735      294.28735      28034.261      28034.261      642.1404       642.1404     
Loop time of 105.985 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.440 hours/ns, 9.435 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    | 105.44     | 105.44     | 105.44     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081711   | 0.081711   | 0.081711   |   0.0 |  0.08
Output  | 0.0001648  | 0.0001648  | 0.0001648  |   0.0 |  0.00
Modify  | 0.39915    | 0.39915    | 0.39915    |   0.0 |  0.38
Other   |            | 0.05949    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3146 ave        3146 max        3146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119006 ave      119006 max      119006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119006
Ave neighs/atom = 59.503
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.944814171241, Press = 0.310909962377101
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    350000  -10442.544     -10442.544     -10518.585     -10518.585      294.28735      294.28735      28034.261      28034.261      642.1404       642.1404     
    351000  -10445.82      -10445.82      -10521.23      -10521.23       291.84591      291.84591      28075.118      28075.118     -1923.6138     -1923.6138    
Loop time of 104.23 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.953 hours/ns, 9.594 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    | 103.69     | 103.69     | 103.69     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083003   | 0.083003   | 0.083003   |   0.0 |  0.08
Output  | 0.0001633  | 0.0001633  | 0.0001633  |   0.0 |  0.00
Modify  | 0.39495    | 0.39495    | 0.39495    |   0.0 |  0.38
Other   |            | 0.05873    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3174 ave        3174 max        3174 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119110 ave      119110 max      119110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119110
Ave neighs/atom = 59.555
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
28041.5590249106

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0