# 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 2.999911956489086*${_u_distance}
variable latticeconst_converted equal 2.999911956489086*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.99991195648909
Lattice spacing in x,y,z = 2.999912 2.999912 2.999912
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (29.99912 29.99912 29.99912)
  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 (29.99912 29.99912 29.99912)
  create_atoms CPU = 0.000 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_MaiselKoZhang_2017_VNiTi__MO_744610363128_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 26997.6228949697    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 26997.6228949697/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 26997.6228949697/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 26997.6228949697/(1*1*${_u_distance})
variable      V0_metal equal 26997.6228949697/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 26997.6228949697*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 26997.6228949697 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 313.15*${_u_temperature}
variable temp_converted equal 313.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 313.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 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.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  "313.15 - 0.2"
variable      T_up  equal  "313.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_744610363128_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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -10519.085     -10519.085     -10600         -10600          313.15         313.15         26997.623      26997.623      3201.3023      3201.3023    
      1000  -10438.756     -10438.756     -10516.456     -10516.456      300.70667      300.70667      27145.936      27145.936      2544.4772      2544.4772    
Loop time of 47.7137 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.811 ns/day, 13.254 hours/ns, 20.958 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 47.633     | 47.633     | 47.633     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015176   | 0.015176   | 0.015176   |   0.0 |  0.03
Output  | 8.7164e-05 | 8.7164e-05 | 8.7164e-05 |   0.0 |  0.00
Modify  | 0.06025    | 0.06025    | 0.06025    |   0.0 |  0.13
Other   |            | 0.005442   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       224000 ave      224000 max      224000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 224000
Ave neighs/atom = 112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -10438.756     -10438.756     -10516.456     -10516.456      300.70667      300.70667      27145.936      27145.936      2544.4772      2544.4772    
      2000  -10437.077     -10437.077     -10512.991     -10512.991      293.79457      293.79457      27173.865      27173.865      986.09455      986.09455    
Loop time of 49.4778 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.746 ns/day, 13.744 hours/ns, 20.211 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.398     | 49.398     | 49.398     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014929   | 0.014929   | 0.014929   |   0.0 |  0.03
Output  | 4.7619e-05 | 4.7619e-05 | 4.7619e-05 |   0.0 |  0.00
Modify  | 0.059561   | 0.059561   | 0.059561   |   0.0 |  0.12
Other   |            | 0.005242   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223826 ave      223826 max      223826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223826
Ave neighs/atom = 111.913
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -10437.077     -10437.077     -10512.991     -10512.991      293.79457      293.79457      27173.865      27173.865      986.09455      986.09455    
      3000  -10440.524     -10440.524     -10525.505     -10525.505      328.88715      328.88715      27174.825      27174.825      265.69347      265.69347    
Loop time of 49.5428 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.744 ns/day, 13.762 hours/ns, 20.185 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.463     | 49.463     | 49.463     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014959   | 0.014959   | 0.014959   |   0.0 |  0.03
Output  | 3.5858e-05 | 3.5858e-05 | 3.5858e-05 |   0.0 |  0.00
Modify  | 0.059501   | 0.059501   | 0.059501   |   0.0 |  0.12
Other   |            | 0.005152   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223716 ave      223716 max      223716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223716
Ave neighs/atom = 111.858
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -10440.524     -10440.524     -10525.505     -10525.505      328.88715      328.88715      27174.825      27174.825      265.69347      265.69347    
      4000  -10436.292     -10436.292     -10520.14      -10520.14       324.5009       324.5009       27188.32       27188.32       166.79942      166.79942    
Loop time of 49.6484 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.791 hours/ns, 20.142 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.569     | 49.569     | 49.569     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0149     | 0.0149     | 0.0149     |   0.0 |  0.03
Output  | 4.8071e-05 | 4.8071e-05 | 4.8071e-05 |   0.0 |  0.00
Modify  | 0.059567   | 0.059567   | 0.059567   |   0.0 |  0.12
Other   |            | 0.005191   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223862 ave      223862 max      223862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223862
Ave neighs/atom = 111.931
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -10436.292     -10436.292     -10520.14      -10520.14       324.5009       324.5009       27188.32       27188.32       166.79942      166.79942    
      5000  -10440.773     -10440.773     -10523.877     -10523.877      321.62163      321.62163      27215.957      27215.957     -2074.9775     -2074.9775    
Loop time of 49.6044 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.779 hours/ns, 20.160 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.525     | 49.525     | 49.525     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014961   | 0.014961   | 0.014961   |   0.0 |  0.03
Output  | 2.9455e-05 | 2.9455e-05 | 2.9455e-05 |   0.0 |  0.00
Modify  | 0.059731   | 0.059731   | 0.059731   |   0.0 |  0.12
Other   |            | 0.005164   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223838 ave      223838 max      223838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223838
Ave neighs/atom = 111.919
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.054008075254, Press = 1550.10363388351
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -10440.773     -10440.773     -10523.877     -10523.877      321.62163      321.62163      27215.957      27215.957     -2074.9775     -2074.9775    
      6000  -10436.327     -10436.327     -10518.549     -10518.549      318.20651      318.20651      27240.2        27240.2       -2617.1164     -2617.1164    
Loop time of 49.502 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.745 ns/day, 13.751 hours/ns, 20.201 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.42      | 49.42      | 49.42      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01499    | 0.01499    | 0.01499    |   0.0 |  0.03
Output  | 3.8763e-05 | 3.8763e-05 | 3.8763e-05 |   0.0 |  0.00
Modify  | 0.061929   | 0.061929   | 0.061929   |   0.0 |  0.13
Other   |            | 0.005269   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223834 ave      223834 max      223834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223834
Ave neighs/atom = 111.917
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.604318914306, Press = 125.203273367282
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -10436.327     -10436.327     -10518.549     -10518.549      318.20651      318.20651      27240.2        27240.2       -2617.1164     -2617.1164    
      7000  -10439.545     -10439.545     -10516.853     -10516.853      299.18881      299.18881      27216.207      27216.207     -1472.9574     -1472.9574    
Loop time of 49.5445 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.744 ns/day, 13.762 hours/ns, 20.184 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.462     | 49.462     | 49.462     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01509    | 0.01509    | 0.01509    |   0.0 |  0.03
Output  | 3.8091e-05 | 3.8091e-05 | 3.8091e-05 |   0.0 |  0.00
Modify  | 0.061973   | 0.061973   | 0.061973   |   0.0 |  0.13
Other   |            | 0.005241   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223792 ave      223792 max      223792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223792
Ave neighs/atom = 111.896
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.741612769319, Press = 41.9476396513575
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -10439.545     -10439.545     -10516.853     -10516.853      299.18881      299.18881      27216.207      27216.207     -1472.9574     -1472.9574    
      8000  -10433.477     -10433.477     -10517.32      -10517.32       324.4791       324.4791       27216.72       27216.72      -1370.0774     -1370.0774    
Loop time of 49.5732 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.743 ns/day, 13.770 hours/ns, 20.172 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.491     | 49.491     | 49.491     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014979   | 0.014979   | 0.014979   |   0.0 |  0.03
Output  | 3.6789e-05 | 3.6789e-05 | 3.6789e-05 |   0.0 |  0.00
Modify  | 0.062068   | 0.062068   | 0.062068   |   0.0 |  0.13
Other   |            | 0.005214   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223784 ave      223784 max      223784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223784
Ave neighs/atom = 111.892
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.6498032109, Press = 22.6797778593393
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -10433.477     -10433.477     -10517.32      -10517.32       324.4791       324.4791       27216.72       27216.72      -1370.0774     -1370.0774    
      9000  -10439.194     -10439.194     -10518.957     -10518.957      308.69089      308.69089      27202.97       27202.97      -787.63069     -787.63069    
Loop time of 49.6763 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.799 hours/ns, 20.130 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.594     | 49.594     | 49.594     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014916   | 0.014916   | 0.014916   |   0.0 |  0.03
Output  | 2.8253e-05 | 2.8253e-05 | 2.8253e-05 |   0.0 |  0.00
Modify  | 0.061971   | 0.061971   | 0.061971   |   0.0 |  0.12
Other   |            | 0.005226   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223816 ave      223816 max      223816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223816
Ave neighs/atom = 111.908
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.632810061174, Press = 13.8776730076827
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -10439.194     -10439.194     -10518.957     -10518.957      308.69089      308.69089      27202.97       27202.97      -787.63069     -787.63069    
     10000  -10437.131     -10437.131     -10519.897     -10519.897      320.31083      320.31083      27204.652      27204.652     -885.39173     -885.39173    
Loop time of 49.5921 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.776 hours/ns, 20.164 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.51      | 49.51      | 49.51      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014928   | 0.014928   | 0.014928   |   0.0 |  0.03
Output  | 3.8052e-05 | 3.8052e-05 | 3.8052e-05 |   0.0 |  0.00
Modify  | 0.061943   | 0.061943   | 0.061943   |   0.0 |  0.12
Other   |            | 0.005215   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223818 ave      223818 max      223818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223818
Ave neighs/atom = 111.909
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.56854746093, Press = 3.93151977227722
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -10437.131     -10437.131     -10519.897     -10519.897      320.31083      320.31083      27204.652      27204.652     -885.39173     -885.39173    
     11000  -10437.376     -10437.376     -10519.177     -10519.177      316.58092      316.58092      27184.934      27184.934      259.2619       259.2619     
Loop time of 49.5854 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.774 hours/ns, 20.167 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.503     | 49.503     | 49.503     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014946   | 0.014946   | 0.014946   |   0.0 |  0.03
Output  | 3.8622e-05 | 3.8622e-05 | 3.8622e-05 |   0.0 |  0.00
Modify  | 0.061993   | 0.061993   | 0.061993   |   0.0 |  0.13
Other   |            | 0.005205   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223832 ave      223832 max      223832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223832
Ave neighs/atom = 111.916
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.147079778748, Press = -3.35695155548496
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -10437.376     -10437.376     -10519.177     -10519.177      316.58092      316.58092      27184.934      27184.934      259.2619       259.2619     
     12000  -10439.39      -10439.39      -10520.826     -10520.826      315.16809      315.16809      27163.306      27163.306      1446.7393      1446.7393    
Loop time of 49.5909 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.775 hours/ns, 20.165 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.509     | 49.509     | 49.509     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014922   | 0.014922   | 0.014922   |   0.0 |  0.03
Output  | 3.8702e-05 | 3.8702e-05 | 3.8702e-05 |   0.0 |  0.00
Modify  | 0.061975   | 0.061975   | 0.061975   |   0.0 |  0.12
Other   |            | 0.005212   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223830 ave      223830 max      223830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223830
Ave neighs/atom = 111.915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.006553790111, Press = 2.69800383011145
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -10439.39      -10439.39      -10520.826     -10520.826      315.16809      315.16809      27163.306      27163.306      1446.7393      1446.7393    
     13000  -10436.719     -10436.719     -10516.825     -10516.825      310.01773      310.01773      27159.545      27159.545      1805.5803      1805.5803    
Loop time of 49.5948 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.776 hours/ns, 20.163 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.513     | 49.513     | 49.513     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015011   | 0.015011   | 0.015011   |   0.0 |  0.03
Output  | 3.8051e-05 | 3.8051e-05 | 3.8051e-05 |   0.0 |  0.00
Modify  | 0.061928   | 0.061928   | 0.061928   |   0.0 |  0.12
Other   |            | 0.005218   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223836 ave      223836 max      223836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223836
Ave neighs/atom = 111.918
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.870482840695, Press = 8.22950391743859
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -10436.719     -10436.719     -10516.825     -10516.825      310.01773      310.01773      27159.545      27159.545      1805.5803      1805.5803    
     14000  -10441.017     -10441.017     -10518.95      -10518.95       301.60827      301.60827      27158.116      27158.116      1574.8281      1574.8281    
Loop time of 49.7224 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.738 ns/day, 13.812 hours/ns, 20.112 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.64      | 49.64      | 49.64      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01489    | 0.01489    | 0.01489    |   0.0 |  0.03
Output  | 9.9928e-05 | 9.9928e-05 | 9.9928e-05 |   0.0 |  0.00
Modify  | 0.061961   | 0.061961   | 0.061961   |   0.0 |  0.12
Other   |            | 0.005253   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223834 ave      223834 max      223834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223834
Ave neighs/atom = 111.917
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.793933805495, Press = 9.71728108575563
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -10441.017     -10441.017     -10518.95      -10518.95       301.60827      301.60827      27158.116      27158.116      1574.8281      1574.8281    
     15000  -10436.834     -10436.834     -10518.636     -10518.636      316.58012      316.58012      27162.255      27162.255      1581.4607      1581.4607    
Loop time of 49.6251 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.785 hours/ns, 20.151 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.543     | 49.543     | 49.543     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014965   | 0.014965   | 0.014965   |   0.0 |  0.03
Output  | 2.8193e-05 | 2.8193e-05 | 2.8193e-05 |   0.0 |  0.00
Modify  | 0.061961   | 0.061961   | 0.061961   |   0.0 |  0.12
Other   |            | 0.005199   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223822 ave      223822 max      223822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223822
Ave neighs/atom = 111.911
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.787804229739, Press = 10.5999926750307
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -10436.834     -10436.834     -10518.636     -10518.636      316.58012      316.58012      27162.255      27162.255      1581.4607      1581.4607    
     16000  -10438.929     -10438.929     -10517.709     -10517.709      304.88576      304.88576      27162.648      27162.648      1450.4553      1450.4553    
Loop time of 49.6231 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.784 hours/ns, 20.152 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.541     | 49.541     | 49.541     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014938   | 0.014938   | 0.014938   |   0.0 |  0.03
Output  | 3.9194e-05 | 3.9194e-05 | 3.9194e-05 |   0.0 |  0.00
Modify  | 0.061963   | 0.061963   | 0.061963   |   0.0 |  0.12
Other   |            | 0.005212   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223826 ave      223826 max      223826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223826
Ave neighs/atom = 111.913
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.987289464408, Press = 11.818818758976
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -10438.929     -10438.929     -10517.709     -10517.709      304.88576      304.88576      27162.648      27162.648      1450.4553      1450.4553    
     17000  -10434.73      -10434.73      -10515.834     -10515.834      313.8812       313.8812       27175.498      27175.498      938.74418      938.74418    
Loop time of 49.6772 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.799 hours/ns, 20.130 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.595     | 49.595     | 49.595     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014979   | 0.014979   | 0.014979   |   0.0 |  0.03
Output  | 3.737e-05  | 3.737e-05  | 3.737e-05  |   0.0 |  0.00
Modify  | 0.061944   | 0.061944   | 0.061944   |   0.0 |  0.12
Other   |            | 0.005229   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223808 ave      223808 max      223808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223808
Ave neighs/atom = 111.904
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.064415384626, Press = 15.9768711202689
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -10434.73      -10434.73      -10515.834     -10515.834      313.8812       313.8812       27175.498      27175.498      938.74418      938.74418    
     18000  -10440.759     -10440.759     -10522.953     -10522.953      318.09845      318.09845      27198.614      27198.614     -863.83007     -863.83007    
Loop time of 49.6095 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.780 hours/ns, 20.157 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.527     | 49.527     | 49.527     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014974   | 0.014974   | 0.014974   |   0.0 |  0.03
Output  | 3.9364e-05 | 3.9364e-05 | 3.9364e-05 |   0.0 |  0.00
Modify  | 0.061926   | 0.061926   | 0.061926   |   0.0 |  0.12
Other   |            | 0.005286   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223794 ave      223794 max      223794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223794
Ave neighs/atom = 111.897
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.163724272141, Press = 12.134818692663
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -10440.759     -10440.759     -10522.953     -10522.953      318.09845      318.09845      27198.614      27198.614     -863.83007     -863.83007    
     19000  -10434.819     -10434.819     -10518.214     -10518.214      322.74586      322.74586      27212.177      27212.177     -1099.2532     -1099.2532    
Loop time of 49.6016 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.778 hours/ns, 20.161 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.519     | 49.519     | 49.519     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014952   | 0.014952   | 0.014952   |   0.0 |  0.03
Output  | 3.6829e-05 | 3.6829e-05 | 3.6829e-05 |   0.0 |  0.00
Modify  | 0.061921   | 0.061921   | 0.061921   |   0.0 |  0.12
Other   |            | 0.005341   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223824 ave      223824 max      223824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223824
Ave neighs/atom = 111.912
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.15796501472, Press = 8.03003804282843
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -10434.819     -10434.819     -10518.214     -10518.214      322.74586      322.74586      27212.177      27212.177     -1099.2532     -1099.2532    
     20000  -10438.873     -10438.873     -10518.715     -10518.715      308.99596      308.99596      27205.722      27205.722     -1008.0875     -1008.0875    
Loop time of 49.6854 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.802 hours/ns, 20.127 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.603     | 49.603     | 49.603     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014926   | 0.014926   | 0.014926   |   0.0 |  0.03
Output  | 3.5877e-05 | 3.5877e-05 | 3.5877e-05 |   0.0 |  0.00
Modify  | 0.061933   | 0.061933   | 0.061933   |   0.0 |  0.12
Other   |            | 0.005206   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223790 ave      223790 max      223790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223790
Ave neighs/atom = 111.895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.229180026415, Press = 6.97829884638954
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -10438.873     -10438.873     -10518.715     -10518.715      308.99596      308.99596      27205.722      27205.722     -1008.0875     -1008.0875    
     21000  -10436.933     -10436.933     -10517.137     -10517.137      310.39941      310.39941      27213.372      27213.372     -1330.3703     -1330.3703    
Loop time of 49.6973 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.805 hours/ns, 20.122 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.615     | 49.615     | 49.615     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014978   | 0.014978   | 0.014978   |   0.0 |  0.03
Output  | 2.9445e-05 | 2.9445e-05 | 2.9445e-05 |   0.0 |  0.00
Modify  | 0.06199    | 0.06199    | 0.06199    |   0.0 |  0.12
Other   |            | 0.00532    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223846 ave      223846 max      223846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223846
Ave neighs/atom = 111.923
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.175983651905, Press = 5.12739104157828
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -10436.933     -10436.933     -10517.137     -10517.137      310.39941      310.39941      27213.372      27213.372     -1330.3703     -1330.3703    
     22000  -10441.536     -10441.536     -10519.765     -10519.765      302.75359      302.75359      27210.989      27210.989     -1481.0033     -1481.0033    
Loop time of 49.6724 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.798 hours/ns, 20.132 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.59      | 49.59      | 49.59      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01497    | 0.01497    | 0.01497    |   0.0 |  0.03
Output  | 3.7541e-05 | 3.7541e-05 | 3.7541e-05 |   0.0 |  0.00
Modify  | 0.061863   | 0.061863   | 0.061863   |   0.0 |  0.12
Other   |            | 0.005274   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223754 ave      223754 max      223754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223754
Ave neighs/atom = 111.877
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.015461814203, Press = 3.317258105123
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -10441.536     -10441.536     -10519.765     -10519.765      302.75359      302.75359      27210.989      27210.989     -1481.0033     -1481.0033    
     23000  -10436.926     -10436.926     -10519.639     -10519.639      320.1091       320.1091       27205.255      27205.255     -792.93392     -792.93392    
Loop time of 49.5769 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.743 ns/day, 13.771 hours/ns, 20.171 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.495     | 49.495     | 49.495     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015009   | 0.015009   | 0.015009   |   0.0 |  0.03
Output  | 3.8702e-05 | 3.8702e-05 | 3.8702e-05 |   0.0 |  0.00
Modify  | 0.06196    | 0.06196    | 0.06196    |   0.0 |  0.12
Other   |            | 0.00522    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223808 ave      223808 max      223808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223808
Ave neighs/atom = 111.904
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.950836932856, Press = 1.99436304368815
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -10436.926     -10436.926     -10519.639     -10519.639      320.1091       320.1091       27205.255      27205.255     -792.93392     -792.93392    
     24000  -10440.729     -10440.729     -10522.314     -10522.314      315.73976      315.73976      27186.677      27186.677     -155.55085     -155.55085    
Loop time of 49.7334 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.737 ns/day, 13.815 hours/ns, 20.107 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.651     | 49.651     | 49.651     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014955   | 0.014955   | 0.014955   |   0.0 |  0.03
Output  | 3.8062e-05 | 3.8062e-05 | 3.8062e-05 |   0.0 |  0.00
Modify  | 0.061952   | 0.061952   | 0.061952   |   0.0 |  0.12
Other   |            | 0.005198   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223808 ave      223808 max      223808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223808
Ave neighs/atom = 111.904
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.910538247404, Press = 1.40028432118082
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -10440.729     -10440.729     -10522.314     -10522.314      315.73976      315.73976      27186.677      27186.677     -155.55085     -155.55085    
     25000  -10437.44      -10437.44      -10517.304     -10517.304      309.08013      309.08013      27166.814      27166.814      1360.2968      1360.2968    
Loop time of 49.7006 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.738 ns/day, 13.806 hours/ns, 20.120 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.618     | 49.618     | 49.618     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014983   | 0.014983   | 0.014983   |   0.0 |  0.03
Output  | 3.6097e-05 | 3.6097e-05 | 3.6097e-05 |   0.0 |  0.00
Modify  | 0.061933   | 0.061933   | 0.061933   |   0.0 |  0.12
Other   |            | 0.005199   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223852 ave      223852 max      223852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223852
Ave neighs/atom = 111.926
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.964038662109, Press = 1.86732607200515
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -10437.44      -10437.44      -10517.304     -10517.304      309.08013      309.08013      27166.814      27166.814      1360.2968      1360.2968    
     26000  -10436.92      -10436.92      -10517.781     -10517.781      312.94157      312.94157      27120.883      27120.883      3903.0817      3903.0817    
Loop time of 49.7618 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.736 ns/day, 13.823 hours/ns, 20.096 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.68      | 49.68      | 49.68      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014918   | 0.014918   | 0.014918   |   0.0 |  0.03
Output  | 3.0568e-05 | 3.0568e-05 | 3.0568e-05 |   0.0 |  0.00
Modify  | 0.061972   | 0.061972   | 0.061972   |   0.0 |  0.12
Other   |            | 0.005199   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223800 ave      223800 max      223800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223800
Ave neighs/atom = 111.9
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.001172575862, Press = 1.93146697314329
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -10436.92      -10436.92      -10517.781     -10517.781      312.94157      312.94157      27120.883      27120.883      3903.0817      3903.0817    
     27000  -10439.811     -10439.811     -10521.623     -10521.623      316.61969      316.61969      27129.142      27129.142      3206.4898      3206.4898    
Loop time of 49.6049 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.779 hours/ns, 20.159 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.523     | 49.523     | 49.523     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014942   | 0.014942   | 0.014942   |   0.0 |  0.03
Output  | 3.9654e-05 | 3.9654e-05 | 3.9654e-05 |   0.0 |  0.00
Modify  | 0.061942   | 0.061942   | 0.061942   |   0.0 |  0.12
Other   |            | 0.005224   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223832 ave      223832 max      223832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223832
Ave neighs/atom = 111.916
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.083109378847, Press = 4.13213855148475
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -10439.811     -10439.811     -10521.623     -10521.623      316.61969      316.61969      27129.142      27129.142      3206.4898      3206.4898    
     28000  -10437.834     -10437.834     -10519.698     -10519.698      316.82172      316.82172      27161.881      27161.881      1478.1102      1478.1102    
Loop time of 49.6891 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.803 hours/ns, 20.125 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.607     | 49.607     | 49.607     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014982   | 0.014982   | 0.014982   |   0.0 |  0.03
Output  | 2.9586e-05 | 2.9586e-05 | 2.9586e-05 |   0.0 |  0.00
Modify  | 0.061948   | 0.061948   | 0.061948   |   0.0 |  0.12
Other   |            | 0.005245   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223860 ave      223860 max      223860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223860
Ave neighs/atom = 111.93
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.063438796599, Press = 5.01253627333381
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -10437.834     -10437.834     -10519.698     -10519.698      316.82172      316.82172      27161.881      27161.881      1478.1102      1478.1102    
     29000  -10443.87      -10443.87      -10522.504     -10522.504      304.32291      304.32291      27166.337      27166.337      899.18948      899.18948    
Loop time of 49.6304 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.786 hours/ns, 20.149 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.548     | 49.548     | 49.548     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014961   | 0.014961   | 0.014961   |   0.0 |  0.03
Output  | 3.8081e-05 | 3.8081e-05 | 3.8081e-05 |   0.0 |  0.00
Modify  | 0.0619     | 0.0619     | 0.0619     |   0.0 |  0.12
Other   |            | 0.005199   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223828 ave      223828 max      223828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223828
Ave neighs/atom = 111.914
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.914980507368, Press = 5.08394234968978
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -10443.87      -10443.87      -10522.504     -10522.504      304.32291      304.32291      27166.337      27166.337      899.18948      899.18948    
     30000  -10438.342     -10438.342     -10520.442     -10520.442      317.73238      317.73238      27181.181      27181.181      347.73237      347.73237    
Loop time of 49.6793 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.800 hours/ns, 20.129 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.597     | 49.597     | 49.597     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014938   | 0.014938   | 0.014938   |   0.0 |  0.03
Output  | 3.8252e-05 | 3.8252e-05 | 3.8252e-05 |   0.0 |  0.00
Modify  | 0.061957   | 0.061957   | 0.061957   |   0.0 |  0.12
Other   |            | 0.00525    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223860 ave      223860 max      223860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223860
Ave neighs/atom = 111.93
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.853648934968, Press = 5.38961243177518
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -10438.342     -10438.342     -10520.442     -10520.442      317.73238      317.73238      27181.181      27181.181      347.73237      347.73237    
     31000  -10433.714     -10433.714     -10515.333     -10515.333      315.87565      315.87565      27217.351      27217.351     -1203.4151     -1203.4151    
Loop time of 49.599 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.778 hours/ns, 20.162 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.517     | 49.517     | 49.517     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015001   | 0.015001   | 0.015001   |   0.0 |  0.03
Output  | 3.5387e-05 | 3.5387e-05 | 3.5387e-05 |   0.0 |  0.00
Modify  | 0.062003   | 0.062003   | 0.062003   |   0.0 |  0.13
Other   |            | 0.005256   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223812 ave      223812 max      223812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223812
Ave neighs/atom = 111.906
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.874984871167, Press = 6.58778155213957
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -10433.714     -10433.714     -10515.333     -10515.333      315.87565      315.87565      27217.351      27217.351     -1203.4151     -1203.4151    
     32000  -10439.738     -10439.738     -10518.58      -10518.58       305.12873      305.12873      27241.767      27241.767     -3031.7962     -3031.7962    
Loop time of 49.532 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.744 ns/day, 13.759 hours/ns, 20.189 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.45      | 49.45      | 49.45      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014925   | 0.014925   | 0.014925   |   0.0 |  0.03
Output  | 2.9115e-05 | 2.9115e-05 | 2.9115e-05 |   0.0 |  0.00
Modify  | 0.061923   | 0.061923   | 0.061923   |   0.0 |  0.13
Other   |            | 0.005294   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223716 ave      223716 max      223716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223716
Ave neighs/atom = 111.858
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.906881763828, Press = 5.93807696657954
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -10439.738     -10439.738     -10518.58      -10518.58       305.12873      305.12873      27241.767      27241.767     -3031.7962     -3031.7962    
     33000  -10436.782     -10436.782     -10519.906     -10519.906      321.70115      321.70115      27224.963      27224.963     -1930.136      -1930.136     
Loop time of 49.5322 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.744 ns/day, 13.759 hours/ns, 20.189 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.45      | 49.45      | 49.45      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014926   | 0.014926   | 0.014926   |   0.0 |  0.03
Output  | 3.8472e-05 | 3.8472e-05 | 3.8472e-05 |   0.0 |  0.00
Modify  | 0.061945   | 0.061945   | 0.061945   |   0.0 |  0.13
Other   |            | 0.005223   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223806 ave      223806 max      223806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223806
Ave neighs/atom = 111.903
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.964465142706, Press = 3.97660926764726
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -10436.782     -10436.782     -10519.906     -10519.906      321.70115      321.70115      27224.963      27224.963     -1930.136      -1930.136     
     34000  -10437.845     -10437.845     -10517.932     -10517.932      309.94408      309.94408      27225.396      27225.396     -1908.6706     -1908.6706    
Loop time of 49.5978 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.777 hours/ns, 20.162 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    | 49.516     | 49.516     | 49.516     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01495    | 0.01495    | 0.01495    |   0.0 |  0.03
Output  | 3.734e-05  | 3.734e-05  | 3.734e-05  |   0.0 |  0.00
Modify  | 0.061987   | 0.061987   | 0.061987   |   0.0 |  0.12
Other   |            | 0.005225   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223822 ave      223822 max      223822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223822
Ave neighs/atom = 111.911
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.928392860482, Press = 2.83052469509656
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -10437.845     -10437.845     -10517.932     -10517.932      309.94408      309.94408      27225.396      27225.396     -1908.6706     -1908.6706    
     35000  -10437.659     -10437.659     -10517.975     -10517.975      310.82797      310.82797      27220.33       27220.33      -1669.2107     -1669.2107    
Loop time of 49.5803 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.743 ns/day, 13.772 hours/ns, 20.169 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    | 49.498     | 49.498     | 49.498     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014919   | 0.014919   | 0.014919   |   0.0 |  0.03
Output  | 3.7892e-05 | 3.7892e-05 | 3.7892e-05 |   0.0 |  0.00
Modify  | 0.061932   | 0.061932   | 0.061932   |   0.0 |  0.12
Other   |            | 0.005258   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223804 ave      223804 max      223804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223804
Ave neighs/atom = 111.902
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.020016052784, Press = 1.84880239375686
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -10437.659     -10437.659     -10517.975     -10517.975      310.82797      310.82797      27220.33       27220.33      -1669.2107     -1669.2107    
     36000  -10438.09      -10438.09      -10519.797     -10519.797      316.21243      316.21243      27203.707      27203.707     -783.54135     -783.54135    
Loop time of 49.6155 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.782 hours/ns, 20.155 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    | 49.533     | 49.533     | 49.533     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01492    | 0.01492    | 0.01492    |   0.0 |  0.03
Output  | 3.8502e-05 | 3.8502e-05 | 3.8502e-05 |   0.0 |  0.00
Modify  | 0.06187    | 0.06187    | 0.06187    |   0.0 |  0.12
Other   |            | 0.005202   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223788 ave      223788 max      223788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223788
Ave neighs/atom = 111.894
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.984752621793, Press = 1.31578548103565
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -10438.09      -10438.09      -10519.797     -10519.797      316.21243      316.21243      27203.707      27203.707     -783.54135     -783.54135    
     37000  -10439.186     -10439.186     -10518.973     -10518.973      308.78568      308.78568      27187.069      27187.069      258.66428      258.66428    
Loop time of 49.5663 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.743 ns/day, 13.768 hours/ns, 20.175 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    | 49.484     | 49.484     | 49.484     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014962   | 0.014962   | 0.014962   |   0.0 |  0.03
Output  | 3.5547e-05 | 3.5547e-05 | 3.5547e-05 |   0.0 |  0.00
Modify  | 0.061868   | 0.061868   | 0.061868   |   0.0 |  0.12
Other   |            | 0.005198   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223828 ave      223828 max      223828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223828
Ave neighs/atom = 111.914
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.978492737989, Press = 1.52460728666829
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -10439.186     -10439.186     -10518.973     -10518.973      308.78568      308.78568      27187.069      27187.069      258.66428      258.66428    
     38000  -10439.747     -10439.747     -10518.487     -10518.487      304.73143      304.73143      27174.383      27174.383      720.80321      720.80321    
Loop time of 49.5948 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.776 hours/ns, 20.163 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    | 49.513     | 49.513     | 49.513     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014925   | 0.014925   | 0.014925   |   0.0 |  0.03
Output  | 2.9495e-05 | 2.9495e-05 | 2.9495e-05 |   0.0 |  0.00
Modify  | 0.061951   | 0.061951   | 0.061951   |   0.0 |  0.12
Other   |            | 0.005268   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223832 ave      223832 max      223832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223832
Ave neighs/atom = 111.916
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.929795920793, Press = 2.27104215103249
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -10439.747     -10439.747     -10518.487     -10518.487      304.73143      304.73143      27174.383      27174.383      720.80321      720.80321    
     39000  -10443.032     -10443.032     -10522.923     -10522.923      309.18382      309.18382      27166.133      27166.133      967.64046      967.64046    
Loop time of 49.5881 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.774 hours/ns, 20.166 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    | 49.506     | 49.506     | 49.506     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014987   | 0.014987   | 0.014987   |   0.0 |  0.03
Output  | 3.8633e-05 | 3.8633e-05 | 3.8633e-05 |   0.0 |  0.00
Modify  | 0.061904   | 0.061904   | 0.061904   |   0.0 |  0.12
Other   |            | 0.00521    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223854 ave      223854 max      223854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223854
Ave neighs/atom = 111.927
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.901778285971, Press = 2.61100471531663
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -10443.032     -10443.032     -10522.923     -10522.923      309.18382      309.18382      27166.133      27166.133      967.64046      967.64046    
     40000  -10438.023     -10438.023     -10516.878     -10516.878      305.1761       305.1761       27167.855      27167.855      1226.6341      1226.6341    
Loop time of 49.5704 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.743 ns/day, 13.770 hours/ns, 20.173 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    | 49.488     | 49.488     | 49.488     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014921   | 0.014921   | 0.014921   |   0.0 |  0.03
Output  | 3.8603e-05 | 3.8603e-05 | 3.8603e-05 |   0.0 |  0.00
Modify  | 0.061922   | 0.061922   | 0.061922   |   0.0 |  0.12
Other   |            | 0.005297   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223868 ave      223868 max      223868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223868
Ave neighs/atom = 111.934
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.80526081012, Press = 3.23655262695014
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -10438.023     -10438.023     -10516.878     -10516.878      305.1761       305.1761       27167.855      27167.855      1226.6341      1226.6341    
     41000  -10439.459     -10439.459     -10520.341     -10520.341      313.02007      313.02007      27167.464      27167.464      1069.8838      1069.8838    
Loop time of 49.5866 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.774 hours/ns, 20.167 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    | 49.505     | 49.505     | 49.505     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014924   | 0.014924   | 0.014924   |   0.0 |  0.03
Output  | 4.0767e-05 | 4.0767e-05 | 4.0767e-05 |   0.0 |  0.00
Modify  | 0.061867   | 0.061867   | 0.061867   |   0.0 |  0.12
Other   |            | 0.005206   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223820 ave      223820 max      223820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223820
Ave neighs/atom = 111.91
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.786451322215, Press = 3.53733576441248
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -10439.459     -10439.459     -10520.341     -10520.341      313.02007      313.02007      27167.464      27167.464      1069.8838      1069.8838    
     42000  -10435.829     -10435.829     -10517.185     -10517.185      314.85758      314.85758      27173.917      27173.917      1071.2015      1071.2015    
Loop time of 49.5438 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.744 ns/day, 13.762 hours/ns, 20.184 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    | 49.462     | 49.462     | 49.462     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014931   | 0.014931   | 0.014931   |   0.0 |  0.03
Output  | 3.9905e-05 | 3.9905e-05 | 3.9905e-05 |   0.0 |  0.00
Modify  | 0.061925   | 0.061925   | 0.061925   |   0.0 |  0.12
Other   |            | 0.005203   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223848 ave      223848 max      223848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223848
Ave neighs/atom = 111.924
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.791352247875, Press = 4.98238289064768
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -10435.829     -10435.829     -10517.185     -10517.185      314.85758      314.85758      27173.917      27173.917      1071.2015      1071.2015    
     43000  -10440.516     -10440.516     -10519.566     -10519.566      305.93349      305.93349      27199.268      27199.268     -740.13271     -740.13271    
Loop time of 49.5475 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.744 ns/day, 13.763 hours/ns, 20.183 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    | 49.465     | 49.465     | 49.465     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01495    | 0.01495    | 0.01495    |   0.0 |  0.03
Output  | 2.9555e-05 | 2.9555e-05 | 2.9555e-05 |   0.0 |  0.00
Modify  | 0.061829   | 0.061829   | 0.061829   |   0.0 |  0.12
Other   |            | 0.005229   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223790 ave      223790 max      223790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223790
Ave neighs/atom = 111.895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.758068248681, Press = 4.64154741041338
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -10440.516     -10440.516     -10519.566     -10519.566      305.93349      305.93349      27199.268      27199.268     -740.13271     -740.13271    
     44000  -10438.176     -10438.176     -10518.343     -10518.343      310.25431      310.25431      27210.621      27210.621     -1351.701      -1351.701     
Loop time of 49.6835 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.801 hours/ns, 20.127 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    | 49.601     | 49.601     | 49.601     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014949   | 0.014949   | 0.014949   |   0.0 |  0.03
Output  | 2.2683e-05 | 2.2683e-05 | 2.2683e-05 |   0.0 |  0.00
Modify  | 0.061861   | 0.061861   | 0.061861   |   0.0 |  0.12
Other   |            | 0.005287   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223808 ave      223808 max      223808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223808
Ave neighs/atom = 111.904
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.70248237591, Press = 3.2170783651129
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -10438.176     -10438.176     -10518.343     -10518.343      310.25431      310.25431      27210.621      27210.621     -1351.701      -1351.701     
     45000  -10440.028     -10440.028     -10518.949     -10518.949      305.43441      305.43441      27207.687      27207.687     -1146.4455     -1146.4455    
Loop time of 49.6681 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.797 hours/ns, 20.134 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    | 49.586     | 49.586     | 49.586     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014903   | 0.014903   | 0.014903   |   0.0 |  0.03
Output  | 3.5237e-05 | 3.5237e-05 | 3.5237e-05 |   0.0 |  0.00
Modify  | 0.061901   | 0.061901   | 0.061901   |   0.0 |  0.12
Other   |            | 0.005212   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223776 ave      223776 max      223776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223776
Ave neighs/atom = 111.888
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.602396391144, Press = 2.76177905326295
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -10440.028     -10440.028     -10518.949     -10518.949      305.43441      305.43441      27207.687      27207.687     -1146.4455     -1146.4455    
     46000  -10439.844     -10439.844     -10519.889     -10519.889      309.78361      309.78361      27215.414      27215.414     -1671.9366     -1671.9366    
Loop time of 49.6301 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.786 hours/ns, 20.149 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    | 49.548     | 49.548     | 49.548     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014986   | 0.014986   | 0.014986   |   0.0 |  0.03
Output  | 3.715e-05  | 3.715e-05  | 3.715e-05  |   0.0 |  0.00
Modify  | 0.061918   | 0.061918   | 0.061918   |   0.0 |  0.12
Other   |            | 0.005259   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223846 ave      223846 max      223846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223846
Ave neighs/atom = 111.923
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.582842075133, Press = 2.29162324233552
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -10439.844     -10439.844     -10519.889     -10519.889      309.78361      309.78361      27215.414      27215.414     -1671.9366     -1671.9366    
     47000  -10433.437     -10433.437     -10517.67      -10517.67       325.98952      325.98952      27221.241      27221.241     -1595.3545     -1595.3545    
Loop time of 49.6528 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.792 hours/ns, 20.140 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    | 49.571     | 49.571     | 49.571     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014958   | 0.014958   | 0.014958   |   0.0 |  0.03
Output  | 4.0125e-05 | 4.0125e-05 | 4.0125e-05 |   0.0 |  0.00
Modify  | 0.061885   | 0.061885   | 0.061885   |   0.0 |  0.12
Other   |            | 0.00528    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223804 ave      223804 max      223804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223804
Ave neighs/atom = 111.902
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.617717206389, Press = 1.43475275096338
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -10433.437     -10433.437     -10517.67      -10517.67       325.98952      325.98952      27221.241      27221.241     -1595.3545     -1595.3545    
     48000  -10440.33      -10440.33      -10519.31      -10519.31       305.659        305.659        27203.18       27203.18      -845.63234     -845.63234    
Loop time of 49.6705 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.797 hours/ns, 20.133 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    | 49.588     | 49.588     | 49.588     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015016   | 0.015016   | 0.015016   |   0.0 |  0.03
Output  | 3.1208e-05 | 3.1208e-05 | 3.1208e-05 |   0.0 |  0.00
Modify  | 0.06189    | 0.06189    | 0.06189    |   0.0 |  0.12
Other   |            | 0.005195   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223842 ave      223842 max      223842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223842
Ave neighs/atom = 111.921
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.629166799143, Press = 0.833333714429991
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -10440.33      -10440.33      -10519.31      -10519.31       305.659        305.659        27203.18       27203.18      -845.63234     -845.63234    
     49000  -10440.017     -10440.017     -10520.682     -10520.682      312.17952      312.17952      27180.928      27180.928      168.00965      168.00965    
Loop time of 49.6759 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.799 hours/ns, 20.131 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.594     | 49.594     | 49.594     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014943   | 0.014943   | 0.014943   |   0.0 |  0.03
Output  | 2.2322e-05 | 2.2322e-05 | 2.2322e-05 |   0.0 |  0.00
Modify  | 0.061858   | 0.061858   | 0.061858   |   0.0 |  0.12
Other   |            | 0.005262   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223776 ave      223776 max      223776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223776
Ave neighs/atom = 111.888
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.594006931374, Press = 0.028455907621927
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -10440.017     -10440.017     -10520.682     -10520.682      312.17952      312.17952      27180.928      27180.928      168.00965      168.00965    
     50000  -10436.053     -10436.053     -10519.427     -10519.427      322.66724      322.66724      27144.525      27144.525      2554.0267      2554.0267    
Loop time of 49.7261 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.738 ns/day, 13.813 hours/ns, 20.110 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    | 49.644     | 49.644     | 49.644     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014948   | 0.014948   | 0.014948   |   0.0 |  0.03
Output  | 3.5096e-05 | 3.5096e-05 | 3.5096e-05 |   0.0 |  0.00
Modify  | 0.061972   | 0.061972   | 0.061972   |   0.0 |  0.12
Other   |            | 0.005219   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223812 ave      223812 max      223812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223812
Ave neighs/atom = 111.906
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.530961909613, Press = -0.000610421084209463
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -10436.053     -10436.053     -10519.427     -10519.427      322.66724      322.66724      27144.525      27144.525      2554.0267      2554.0267    
     51000  -10441.101     -10441.101     -10520.975     -10520.975      309.12303      309.12303      27154.345      27154.345      1651.0363      1651.0363    
Loop time of 49.6511 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.792 hours/ns, 20.141 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    | 49.569     | 49.569     | 49.569     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014955   | 0.014955   | 0.014955   |   0.0 |  0.03
Output  | 3.7109e-05 | 3.7109e-05 | 3.7109e-05 |   0.0 |  0.00
Modify  | 0.061893   | 0.061893   | 0.061893   |   0.0 |  0.12
Other   |            | 0.005253   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223844 ave      223844 max      223844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223844
Ave neighs/atom = 111.922
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.516477547192, Press = 1.90048405721566
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -10441.101     -10441.101     -10520.975     -10520.975      309.12303      309.12303      27154.345      27154.345      1651.0363      1651.0363    
     52000  -10436.685     -10436.685     -10517.174     -10517.174      311.49825      311.49825      27161.623      27161.623      1797.2939      1797.2939    
Loop time of 49.6605 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.795 hours/ns, 20.137 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    | 49.578     | 49.578     | 49.578     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015082   | 0.015082   | 0.015082   |   0.0 |  0.03
Output  | 5.6496e-05 | 5.6496e-05 | 5.6496e-05 |   0.0 |  0.00
Modify  | 0.06188    | 0.06188    | 0.06188    |   0.0 |  0.12
Other   |            | 0.00528    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223858 ave      223858 max      223858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223858
Ave neighs/atom = 111.929
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.493443690055, Press = 2.366939019301
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -10436.685     -10436.685     -10517.174     -10517.174      311.49825      311.49825      27161.623      27161.623      1797.2939      1797.2939    
     53000  -10442.954     -10442.954     -10522.824     -10522.824      309.10663      309.10663      27152.469      27152.469      1718.5365      1718.5365    
Loop time of 49.7042 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.738 ns/day, 13.807 hours/ns, 20.119 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    | 49.622     | 49.622     | 49.622     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014943   | 0.014943   | 0.014943   |   0.0 |  0.03
Output  | 3.6068e-05 | 3.6068e-05 | 3.6068e-05 |   0.0 |  0.00
Modify  | 0.061904   | 0.061904   | 0.061904   |   0.0 |  0.12
Other   |            | 0.005199   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223862 ave      223862 max      223862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223862
Ave neighs/atom = 111.931
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.465189903645, Press = 2.72185608146279
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -10442.954     -10442.954     -10522.824     -10522.824      309.10663      309.10663      27152.469      27152.469      1718.5365      1718.5365    
     54000  -10437.996     -10437.996     -10516.913     -10516.913      305.41486      305.41486      27166.377      27166.377      1327.4448      1327.4448    
Loop time of 49.7132 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.738 ns/day, 13.809 hours/ns, 20.115 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    | 49.631     | 49.631     | 49.631     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014905   | 0.014905   | 0.014905   |   0.0 |  0.03
Output  | 3.0637e-05 | 3.0637e-05 | 3.0637e-05 |   0.0 |  0.00
Modify  | 0.061854   | 0.061854   | 0.061854   |   0.0 |  0.12
Other   |            | 0.005182   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223866 ave      223866 max      223866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223866
Ave neighs/atom = 111.933
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.416360973152, Press = 3.32494670357322
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -10437.996     -10437.996     -10516.913     -10516.913      305.41486      305.41486      27166.377      27166.377      1327.4448      1327.4448    
     55000  -10441.281     -10441.281     -10521.112     -10521.112      308.95238      308.95238      27188.682      27188.682     -236.82389     -236.82389    
Loop time of 49.7925 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.735 ns/day, 13.831 hours/ns, 20.083 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    | 49.71      | 49.71      | 49.71      |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01493    | 0.01493    | 0.01493    |   0.0 |  0.03
Output  | 2.2723e-05 | 2.2723e-05 | 2.2723e-05 |   0.0 |  0.00
Modify  | 0.061846   | 0.061846   | 0.061846   |   0.0 |  0.12
Other   |            | 0.005325   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223868 ave      223868 max      223868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223868
Ave neighs/atom = 111.934
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.363010590032, Press = 4.24916601023655
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -10441.281     -10441.281     -10521.112     -10521.112      308.95238      308.95238      27188.682      27188.682     -236.82389     -236.82389    
     56000  -10439.841     -10439.841     -10519.116     -10519.116      306.80307      306.80307      27211.757      27211.757     -1346.914      -1346.914     
Loop time of 49.4624 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.747 ns/day, 13.740 hours/ns, 20.217 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    | 49.38      | 49.38      | 49.38      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014929   | 0.014929   | 0.014929   |   0.0 |  0.03
Output  | 3.5838e-05 | 3.5838e-05 | 3.5838e-05 |   0.0 |  0.00
Modify  | 0.061899   | 0.061899   | 0.061899   |   0.0 |  0.13
Other   |            | 0.005202   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223810 ave      223810 max      223810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223810
Ave neighs/atom = 111.905
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.378579728348, Press = 3.36353649810475
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -10439.841     -10439.841     -10519.116     -10519.116      306.80307      306.80307      27211.757      27211.757     -1346.914      -1346.914     
     57000  -10434.104     -10434.104     -10517.703     -10517.703      323.53676      323.53676      27219.337      27219.337     -1338.4828     -1338.4828    
Loop time of 49.6926 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.804 hours/ns, 20.124 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    | 49.61      | 49.61      | 49.61      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014935   | 0.014935   | 0.014935   |   0.0 |  0.03
Output  | 3.9344e-05 | 3.9344e-05 | 3.9344e-05 |   0.0 |  0.00
Modify  | 0.061911   | 0.061911   | 0.061911   |   0.0 |  0.12
Other   |            | 0.005288   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223832 ave      223832 max      223832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223832
Ave neighs/atom = 111.916
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.408932731092, Press = 2.41892344386916
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -10434.104     -10434.104     -10517.703     -10517.703      323.53676      323.53676      27219.337      27219.337     -1338.4828     -1338.4828    
     58000  -10438.507     -10438.507     -10520.254     -10520.254      316.37168      316.37168      27211.264      27211.264     -1330.2699     -1330.2699    
Loop time of 49.6223 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.784 hours/ns, 20.152 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    | 49.54      | 49.54      | 49.54      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014951   | 0.014951   | 0.014951   |   0.0 |  0.03
Output  | 3.5887e-05 | 3.5887e-05 | 3.5887e-05 |   0.0 |  0.00
Modify  | 0.061877   | 0.061877   | 0.061877   |   0.0 |  0.12
Other   |            | 0.005262   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223832 ave      223832 max      223832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223832
Ave neighs/atom = 111.916
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.445452621621, Press = 2.08608953131943
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -10438.507     -10438.507     -10520.254     -10520.254      316.37168      316.37168      27211.264      27211.264     -1330.2699     -1330.2699    
     59000  -10432.507     -10432.507     -10517.431     -10517.431      328.66689      328.66689      27222.94       27222.94      -1553.7439     -1553.7439    
Loop time of 49.6501 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.792 hours/ns, 20.141 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    | 49.568     | 49.568     | 49.568     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01496    | 0.01496    | 0.01496    |   0.0 |  0.03
Output  | 3.6298e-05 | 3.6298e-05 | 3.6298e-05 |   0.0 |  0.00
Modify  | 0.061944   | 0.061944   | 0.061944   |   0.0 |  0.12
Other   |            | 0.005315   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223838 ave      223838 max      223838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223838
Ave neighs/atom = 111.919
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.490724523708, Press = 1.74697800077691
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -10432.507     -10432.507     -10517.431     -10517.431      328.66689      328.66689      27222.94       27222.94      -1553.7439     -1553.7439    
     60000  -10437.917     -10437.917     -10521.506     -10521.506      323.49788      323.49788      27235.442      27235.442     -2757.7312     -2757.7312    
Loop time of 49.6628 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.795 hours/ns, 20.136 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    | 49.581     | 49.581     | 49.581     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015023   | 0.015023   | 0.015023   |   0.0 |  0.03
Output  | 3.0196e-05 | 3.0196e-05 | 3.0196e-05 |   0.0 |  0.00
Modify  | 0.061892   | 0.061892   | 0.061892   |   0.0 |  0.12
Other   |            | 0.005204   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223806 ave      223806 max      223806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223806
Ave neighs/atom = 111.903
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.501924755582, Press = 1.16331412053417
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -10437.917     -10437.917     -10521.506     -10521.506      323.49788      323.49788      27235.442      27235.442     -2757.7312     -2757.7312    
     61000  -10442.909     -10442.909     -10522.353     -10522.353      307.45585      307.45585      27215.44       27215.44      -1858.515      -1858.515     
Loop time of 49.6184 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.783 hours/ns, 20.154 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    | 49.536     | 49.536     | 49.536     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014879   | 0.014879   | 0.014879   |   0.0 |  0.03
Output  | 2.2643e-05 | 2.2643e-05 | 2.2643e-05 |   0.0 |  0.00
Modify  | 0.061844   | 0.061844   | 0.061844   |   0.0 |  0.12
Other   |            | 0.005199   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223844 ave      223844 max      223844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223844
Ave neighs/atom = 111.922
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.47456566345, Press = 0.470872609860666
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -10442.909     -10442.909     -10522.353     -10522.353      307.45585      307.45585      27215.44       27215.44      -1858.515      -1858.515     
     62000  -10437.138     -10437.138     -10521.027     -10521.027      324.65842      324.65842      27192.549      27192.549     -328.99729     -328.99729    
Loop time of 49.5562 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.743 ns/day, 13.766 hours/ns, 20.179 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.474     | 49.474     | 49.474     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014941   | 0.014941   | 0.014941   |   0.0 |  0.03
Output  | 3.5346e-05 | 3.5346e-05 | 3.5346e-05 |   0.0 |  0.00
Modify  | 0.061917   | 0.061917   | 0.061917   |   0.0 |  0.12
Other   |            | 0.005381   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223826 ave      223826 max      223826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223826
Ave neighs/atom = 111.913
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.440916880343, Press = 0.692480079226812
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -10437.138     -10437.138     -10521.027     -10521.027      324.65842      324.65842      27192.549      27192.549     -328.99729     -328.99729    
     63000  -10441.929     -10441.929     -10521.46      -10521.46       307.79348      307.79348      27167.373      27167.373      1000.4107      1000.4107    
Loop time of 49.6777 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.799 hours/ns, 20.130 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.596     | 49.596     | 49.596     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014989   | 0.014989   | 0.014989   |   0.0 |  0.03
Output  | 3.5256e-05 | 3.5256e-05 | 3.5256e-05 |   0.0 |  0.00
Modify  | 0.06188    | 0.06188    | 0.06188    |   0.0 |  0.12
Other   |            | 0.005194   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223834 ave      223834 max      223834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223834
Ave neighs/atom = 111.917
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.391368820761, Press = 1.02219605608951
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -10441.929     -10441.929     -10521.46      -10521.46       307.79348      307.79348      27167.373      27167.373      1000.4107      1000.4107    
     64000  -10438.935     -10438.935     -10518.957     -10518.957      309.69155      309.69155      27167.163      27167.163      1176.7965      1176.7965    
Loop time of 49.6506 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.792 hours/ns, 20.141 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    | 49.569     | 49.569     | 49.569     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014993   | 0.014993   | 0.014993   |   0.0 |  0.03
Output  | 3.6679e-05 | 3.6679e-05 | 3.6679e-05 |   0.0 |  0.00
Modify  | 0.061878   | 0.061878   | 0.061878   |   0.0 |  0.12
Other   |            | 0.005204   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223854 ave      223854 max      223854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223854
Ave neighs/atom = 111.927
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.403617318193, Press = 1.39630944805768
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -10438.935     -10438.935     -10518.957     -10518.957      309.69155      309.69155      27167.163      27167.163      1176.7965      1176.7965    
     65000  -10433.999     -10433.999     -10519.556     -10519.556      331.11636      331.11636      27179.071      27179.071      746.45666      746.45666    
Loop time of 49.5241 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.745 ns/day, 13.757 hours/ns, 20.192 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    | 49.442     | 49.442     | 49.442     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014871   | 0.014871   | 0.014871   |   0.0 |  0.03
Output  | 3.5477e-05 | 3.5477e-05 | 3.5477e-05 |   0.0 |  0.00
Modify  | 0.061992   | 0.061992   | 0.061992   |   0.0 |  0.13
Other   |            | 0.005263   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223848 ave      223848 max      223848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223848
Ave neighs/atom = 111.924
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.427843323432, Press = 1.77344060806708
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -10433.999     -10433.999     -10519.556     -10519.556      331.11636      331.11636      27179.071      27179.071      746.45666      746.45666    
     66000  -10439.704     -10439.704     -10520.604     -10520.604      313.09049      313.09049      27179.452      27179.452      312.79827      312.79827    
Loop time of 49.6285 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.786 hours/ns, 20.150 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    | 49.546     | 49.546     | 49.546     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014922   | 0.014922   | 0.014922   |   0.0 |  0.03
Output  | 2.9175e-05 | 2.9175e-05 | 2.9175e-05 |   0.0 |  0.00
Modify  | 0.061831   | 0.061831   | 0.061831   |   0.0 |  0.12
Other   |            | 0.005269   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223838 ave      223838 max      223838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223838
Ave neighs/atom = 111.919
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.455021158696, Press = 1.83128934795385
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -10439.704     -10439.704     -10520.604     -10520.604      313.09049      313.09049      27179.452      27179.452      312.79827      312.79827    
     67000  -10442.228     -10442.228     -10520.073     -10520.073      301.26837      301.26837      27180.897      27180.897      244.20095      244.20095    
Loop time of 49.7152 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.738 ns/day, 13.810 hours/ns, 20.115 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    | 49.633     | 49.633     | 49.633     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014959   | 0.014959   | 0.014959   |   0.0 |  0.03
Output  | 2.2622e-05 | 2.2622e-05 | 2.2622e-05 |   0.0 |  0.00
Modify  | 0.061894   | 0.061894   | 0.061894   |   0.0 |  0.12
Other   |            | 0.005206   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223846 ave      223846 max      223846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223846
Ave neighs/atom = 111.923
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.460238617975, Press = 1.87428334114016
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -10442.228     -10442.228     -10520.073     -10520.073      301.26837      301.26837      27180.897      27180.897      244.20095      244.20095    
     68000  -10438.074     -10438.074     -10518.566     -10518.566      311.51078      311.51078      27188.021      27188.021      90.382462      90.382462    
Loop time of 49.6298 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.786 hours/ns, 20.149 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    | 49.548     | 49.548     | 49.548     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014996   | 0.014996   | 0.014996   |   0.0 |  0.03
Output  | 3.5466e-05 | 3.5466e-05 | 3.5466e-05 |   0.0 |  0.00
Modify  | 0.06201    | 0.06201    | 0.06201    |   0.0 |  0.12
Other   |            | 0.005222   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223830 ave      223830 max      223830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223830
Ave neighs/atom = 111.915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.412868525905, Press = 1.86425963438067
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -10438.074     -10438.074     -10518.566     -10518.566      311.51078      311.51078      27188.021      27188.021      90.382462      90.382462    
     69000  -10440.736     -10440.736     -10519.723     -10519.723      305.68689      305.68689      27192.339      27192.339     -390.17673     -390.17673    
Loop time of 49.6913 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.803 hours/ns, 20.124 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    | 49.609     | 49.609     | 49.609     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015039   | 0.015039   | 0.015039   |   0.0 |  0.03
Output  | 3.4885e-05 | 3.4885e-05 | 3.4885e-05 |   0.0 |  0.00
Modify  | 0.061887   | 0.061887   | 0.061887   |   0.0 |  0.12
Other   |            | 0.005214   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223780 ave      223780 max      223780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223780
Ave neighs/atom = 111.89
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.400921385006, Press = 2.29969659591557
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -10440.736     -10440.736     -10519.723     -10519.723      305.68689      305.68689      27192.339      27192.339     -390.17673     -390.17673    
     70000  -10434.999     -10434.999     -10518.696     -10518.696      323.91785      323.91785      27222.546      27222.546     -1840.8481     -1840.8481    
Loop time of 49.6128 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.781 hours/ns, 20.156 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    | 49.531     | 49.531     | 49.531     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014956   | 0.014956   | 0.014956   |   0.0 |  0.03
Output  | 3.5857e-05 | 3.5857e-05 | 3.5857e-05 |   0.0 |  0.00
Modify  | 0.061904   | 0.061904   | 0.061904   |   0.0 |  0.12
Other   |            | 0.005198   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223792 ave      223792 max      223792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223792
Ave neighs/atom = 111.896
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.40321498796, Press = 2.12887155454685
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -10434.999     -10434.999     -10518.696     -10518.696      323.91785      323.91785      27222.546      27222.546     -1840.8481     -1840.8481    
     71000  -10439.443     -10439.443     -10520.901     -10520.901      315.24904      315.24904      27235.315      27235.315     -2782.1301     -2782.1301    
Loop time of 49.6887 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.802 hours/ns, 20.125 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    | 49.607     | 49.607     | 49.607     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014915   | 0.014915   | 0.014915   |   0.0 |  0.03
Output  | 3.5967e-05 | 3.5967e-05 | 3.5967e-05 |   0.0 |  0.00
Modify  | 0.061966   | 0.061966   | 0.061966   |   0.0 |  0.12
Other   |            | 0.005246   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223796 ave      223796 max      223796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223796
Ave neighs/atom = 111.898
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.420201313972, Press = 1.62770266435108
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -10439.443     -10439.443     -10520.901     -10520.901      315.24904      315.24904      27235.315      27235.315     -2782.1301     -2782.1301    
     72000  -10435.214     -10435.214     -10516.745     -10516.745      315.53387      315.53387      27233.95       27233.95      -2343.5117     -2343.5117    
Loop time of 49.5282 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.744 ns/day, 13.758 hours/ns, 20.191 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    | 49.446     | 49.446     | 49.446     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014995   | 0.014995   | 0.014995   |   0.0 |  0.03
Output  | 2.2262e-05 | 2.2262e-05 | 2.2262e-05 |   0.0 |  0.00
Modify  | 0.06182    | 0.06182    | 0.06182    |   0.0 |  0.12
Other   |            | 0.00524    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223822 ave      223822 max      223822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223822
Ave neighs/atom = 111.911
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.460949012962, Press = 1.07232790048709
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -10435.214     -10435.214     -10516.745     -10516.745      315.53387      315.53387      27233.95       27233.95      -2343.5117     -2343.5117    
     73000  -10440.204     -10440.204     -10521.21      -10521.21       313.50147      313.50147      27206.32       27206.32      -1280.1802     -1280.1802    
Loop time of 49.5989 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.777 hours/ns, 20.162 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    | 49.517     | 49.517     | 49.517     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014941   | 0.014941   | 0.014941   |   0.0 |  0.03
Output  | 3.5998e-05 | 3.5998e-05 | 3.5998e-05 |   0.0 |  0.00
Modify  | 0.061831   | 0.061831   | 0.061831   |   0.0 |  0.12
Other   |            | 0.005205   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223786 ave      223786 max      223786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223786
Ave neighs/atom = 111.893
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.47976804452, Press = 1.02982799398442
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -10440.204     -10440.204     -10521.21      -10521.21       313.50147      313.50147      27206.32       27206.32      -1280.1802     -1280.1802    
     74000  -10438.869     -10438.869     -10518.706     -10518.706      308.97865      308.97865      27189.108      27189.108      11.416104      11.416104    
Loop time of 49.6367 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.788 hours/ns, 20.146 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    | 49.555     | 49.555     | 49.555     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015061   | 0.015061   | 0.015061   |   0.0 |  0.03
Output  | 3.6279e-05 | 3.6279e-05 | 3.6279e-05 |   0.0 |  0.00
Modify  | 0.061835   | 0.061835   | 0.061835   |   0.0 |  0.12
Other   |            | 0.005244   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223840 ave      223840 max      223840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223840
Ave neighs/atom = 111.92
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.48243287314, Press = 1.1273930898287
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -10438.869     -10438.869     -10518.706     -10518.706      308.97865      308.97865      27189.108      27189.108      11.416104      11.416104    
     75000  -10438.537     -10438.537     -10519.513     -10519.513      313.38499      313.38499      27187.126      27187.126      73.234998      73.234998    
Loop time of 49.5489 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.744 ns/day, 13.764 hours/ns, 20.182 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.467     | 49.467     | 49.467     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014986   | 0.014986   | 0.014986   |   0.0 |  0.03
Output  | 3.4966e-05 | 3.4966e-05 | 3.4966e-05 |   0.0 |  0.00
Modify  | 0.06195    | 0.06195    | 0.06195    |   0.0 |  0.13
Other   |            | 0.005333   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223794 ave      223794 max      223794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223794
Ave neighs/atom = 111.897
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.487967848578, Press = 1.09099927074955
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -10438.537     -10438.537     -10519.513     -10519.513      313.38499      313.38499      27187.126      27187.126      73.234998      73.234998    
     76000  -10438.48      -10438.48      -10520.085     -10520.085      315.81667      315.81667      27173.1        27173.1        800.24025      800.24025    
Loop time of 49.6556 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.793 hours/ns, 20.139 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    | 49.574     | 49.574     | 49.574     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014919   | 0.014919   | 0.014919   |   0.0 |  0.03
Output  | 3.5617e-05 | 3.5617e-05 | 3.5617e-05 |   0.0 |  0.00
Modify  | 0.061859   | 0.061859   | 0.061859   |   0.0 |  0.12
Other   |            | 0.005215   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223832 ave      223832 max      223832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223832
Ave neighs/atom = 111.916
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.472069384794, Press = 1.07636332968242
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -10438.48      -10438.48      -10520.085     -10520.085      315.81667      315.81667      27173.1        27173.1        800.24025      800.24025    
     77000  -10437.77      -10437.77      -10518.753     -10518.753      313.4133       313.4133       27130.446      27130.446      3369.7262      3369.7262    
Loop time of 49.6428 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.790 hours/ns, 20.144 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    | 49.561     | 49.561     | 49.561     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014903   | 0.014903   | 0.014903   |   0.0 |  0.03
Output  | 3.4946e-05 | 3.4946e-05 | 3.4946e-05 |   0.0 |  0.00
Modify  | 0.061857   | 0.061857   | 0.061857   |   0.0 |  0.12
Other   |            | 0.005235   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223846 ave      223846 max      223846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223846
Ave neighs/atom = 111.923
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.445913924242, Press = 0.885670319692921
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -10437.77      -10437.77      -10518.753     -10518.753      313.4133       313.4133       27130.446      27130.446      3369.7262      3369.7262    
     78000  -10435.986     -10435.986     -10515.924     -10515.924      309.36836      309.36836      27142.057      27142.057      2874.6959      2874.6959    
Loop time of 49.6474 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.791 hours/ns, 20.142 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    | 49.565     | 49.565     | 49.565     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0149     | 0.0149     | 0.0149     |   0.0 |  0.03
Output  | 2.2252e-05 | 2.2252e-05 | 2.2252e-05 |   0.0 |  0.00
Modify  | 0.061864   | 0.061864   | 0.061864   |   0.0 |  0.12
Other   |            | 0.005248   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223884 ave      223884 max      223884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223884
Ave neighs/atom = 111.942
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.419296570183, Press = 1.47167727817613
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -10435.986     -10435.986     -10515.924     -10515.924      309.36836      309.36836      27142.057      27142.057      2874.6959      2874.6959    
     79000  -10439.001     -10439.001     -10518.775     -10518.775      308.73498      308.73498      27162.347      27162.347      1427.8318      1427.8318    
Loop time of 49.6026 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.778 hours/ns, 20.160 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    | 49.52      | 49.52      | 49.52      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01503    | 0.01503    | 0.01503    |   0.0 |  0.03
Output  | 3.5546e-05 | 3.5546e-05 | 3.5546e-05 |   0.0 |  0.00
Modify  | 0.061892   | 0.061892   | 0.061892   |   0.0 |  0.12
Other   |            | 0.005266   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223814 ave      223814 max      223814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223814
Ave neighs/atom = 111.907
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.463886085402, Press = 1.72575650827768
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -10439.001     -10439.001     -10518.775     -10518.775      308.73498      308.73498      27162.347      27162.347      1427.8318      1427.8318    
     80000  -10435.587     -10435.587     -10518.67      -10518.67       321.5411       321.5411       27180.109      27180.109      663.87086      663.87086    
Loop time of 49.6045 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.779 hours/ns, 20.159 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    | 49.522     | 49.522     | 49.522     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01496    | 0.01496    | 0.01496    |   0.0 |  0.03
Output  | 3.5827e-05 | 3.5827e-05 | 3.5827e-05 |   0.0 |  0.00
Modify  | 0.061891   | 0.061891   | 0.061891   |   0.0 |  0.12
Other   |            | 0.005315   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223864 ave      223864 max      223864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223864
Ave neighs/atom = 111.932
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.467532947653, Press = 1.87535335840899
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -10435.587     -10435.587     -10518.67      -10518.67       321.5411       321.5411       27180.109      27180.109      663.87086      663.87086    
     81000  -10438.706     -10438.706     -10518.767     -10518.767      309.84525      309.84525      27190.569      27190.569     -67.559667     -67.559667    
Loop time of 49.655 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.793 hours/ns, 20.139 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    | 49.573     | 49.573     | 49.573     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014959   | 0.014959   | 0.014959   |   0.0 |  0.03
Output  | 3.9123e-05 | 3.9123e-05 | 3.9123e-05 |   0.0 |  0.00
Modify  | 0.06187    | 0.06187    | 0.06187    |   0.0 |  0.12
Other   |            | 0.005309   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223818 ave      223818 max      223818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223818
Ave neighs/atom = 111.909
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.501852391715, Press = 1.81594047833741
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -10438.706     -10438.706     -10518.767     -10518.767      309.84525      309.84525      27190.569      27190.569     -67.559667     -67.559667    
     82000  -10435.779     -10435.779     -10517.992     -10517.992      318.1752       318.1752       27224.759      27224.759     -1956.1722     -1956.1722    
Loop time of 49.6426 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.790 hours/ns, 20.144 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    | 49.56      | 49.56      | 49.56      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014945   | 0.014945   | 0.014945   |   0.0 |  0.03
Output  | 3.6679e-05 | 3.6679e-05 | 3.6679e-05 |   0.0 |  0.00
Modify  | 0.061874   | 0.061874   | 0.061874   |   0.0 |  0.12
Other   |            | 0.005349   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223834 ave      223834 max      223834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223834
Ave neighs/atom = 111.917
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.508550290874, Press = 2.13117999745486
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -10435.779     -10435.779     -10517.992     -10517.992      318.1752       318.1752       27224.759      27224.759     -1956.1722     -1956.1722    
     83000  -10439.251     -10439.251     -10520.343     -10520.343      313.83321      313.83321      27251.223      27251.223     -3672.6626     -3672.6626    
Loop time of 49.6947 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.804 hours/ns, 20.123 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    | 49.613     | 49.613     | 49.613     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014974   | 0.014974   | 0.014974   |   0.0 |  0.03
Output  | 3.188e-05  | 3.188e-05  | 3.188e-05  |   0.0 |  0.00
Modify  | 0.061901   | 0.061901   | 0.061901   |   0.0 |  0.12
Other   |            | 0.005237   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223804 ave      223804 max      223804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223804
Ave neighs/atom = 111.902
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.479294830851, Press = 1.85866549537115
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -10439.251     -10439.251     -10520.343     -10520.343      313.83321      313.83321      27251.223      27251.223     -3672.6626     -3672.6626    
     84000  -10441.036     -10441.036     -10520.199     -10520.199      306.37094      306.37094      27225.858      27225.858     -2275.1988     -2275.1988    
Loop time of 49.5991 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.778 hours/ns, 20.162 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    | 49.517     | 49.517     | 49.517     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014918   | 0.014918   | 0.014918   |   0.0 |  0.03
Output  | 2.5107e-05 | 2.5107e-05 | 2.5107e-05 |   0.0 |  0.00
Modify  | 0.061898   | 0.061898   | 0.061898   |   0.0 |  0.12
Other   |            | 0.00521    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223778 ave      223778 max      223778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223778
Ave neighs/atom = 111.889
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.458785972079, Press = 1.31937237163835
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -10441.036     -10441.036     -10520.199     -10520.199      306.37094      306.37094      27225.858      27225.858     -2275.1988     -2275.1988    
     85000  -10435.947     -10435.947     -10516.592     -10516.592      312.10242      312.10242      27214.37       27214.37      -1135.2399     -1135.2399    
Loop time of 49.6595 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.794 hours/ns, 20.137 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.577     | 49.577     | 49.577     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014914   | 0.014914   | 0.014914   |   0.0 |  0.03
Output  | 3.7039e-05 | 3.7039e-05 | 3.7039e-05 |   0.0 |  0.00
Modify  | 0.06194    | 0.06194    | 0.06194    |   0.0 |  0.12
Other   |            | 0.005294   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223784 ave      223784 max      223784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223784
Ave neighs/atom = 111.892
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.432965512348, Press = 1.07986506454792
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -10435.947     -10435.947     -10516.592     -10516.592      312.10242      312.10242      27214.37       27214.37      -1135.2399     -1135.2399    
     86000  -10440.913     -10440.913     -10520.929     -10520.929      309.66922      309.66922      27198.796      27198.796     -568.92447     -568.92447    
Loop time of 49.5693 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.743 ns/day, 13.769 hours/ns, 20.174 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    | 49.487     | 49.487     | 49.487     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014933   | 0.014933   | 0.014933   |   0.0 |  0.03
Output  | 3.4925e-05 | 3.4925e-05 | 3.4925e-05 |   0.0 |  0.00
Modify  | 0.061947   | 0.061947   | 0.061947   |   0.0 |  0.12
Other   |            | 0.005274   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223830 ave      223830 max      223830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223830
Ave neighs/atom = 111.915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.42775453695, Press = 0.869684282388074
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -10440.913     -10440.913     -10520.929     -10520.929      309.66922      309.66922      27198.796      27198.796     -568.92447     -568.92447    
     87000  -10436.513     -10436.513     -10517.79      -10517.79       314.55018      314.55018      27191.908      27191.908     -5.3217889     -5.3217889    
Loop time of 49.6475 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.791 hours/ns, 20.142 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    | 49.565     | 49.565     | 49.565     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014982   | 0.014982   | 0.014982   |   0.0 |  0.03
Output  | 3.5276e-05 | 3.5276e-05 | 3.5276e-05 |   0.0 |  0.00
Modify  | 0.061818   | 0.061818   | 0.061818   |   0.0 |  0.12
Other   |            | 0.0052     |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223858 ave      223858 max      223858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223858
Ave neighs/atom = 111.929
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.414427690651, Press = 0.55486325371323
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -10436.513     -10436.513     -10517.79      -10517.79       314.55018      314.55018      27191.908      27191.908     -5.3217889     -5.3217889    
     88000  -10441.834     -10441.834     -10519.582     -10519.582      300.89247      300.89247      27132.674      27132.674      3031.2099      3031.2099    
Loop time of 49.622 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.784 hours/ns, 20.152 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    | 49.54      | 49.54      | 49.54      |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014927   | 0.014927   | 0.014927   |   0.0 |  0.03
Output  | 3.4855e-05 | 3.4855e-05 | 3.4855e-05 |   0.0 |  0.00
Modify  | 0.061894   | 0.061894   | 0.061894   |   0.0 |  0.12
Other   |            | 0.005257   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223834 ave      223834 max      223834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223834
Ave neighs/atom = 111.917
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.39151160683, Press = -0.0806851323176774
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -10441.834     -10441.834     -10519.582     -10519.582      300.89247      300.89247      27132.674      27132.674      3031.2099      3031.2099    
     89000  -10438.803     -10438.803     -10520.755     -10520.755      317.16026      317.16026      27140.006      27140.006      2671.9684      2671.9684    
Loop time of 49.6392 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.789 hours/ns, 20.145 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    | 49.557     | 49.557     | 49.557     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014991   | 0.014991   | 0.014991   |   0.0 |  0.03
Output  | 2.8814e-05 | 2.8814e-05 | 2.8814e-05 |   0.0 |  0.00
Modify  | 0.061907   | 0.061907   | 0.061907   |   0.0 |  0.12
Other   |            | 0.005203   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223850 ave      223850 max      223850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223850
Ave neighs/atom = 111.925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.37651121276, Press = 0.9837158960256
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -10438.803     -10438.803     -10520.755     -10520.755      317.16026      317.16026      27140.006      27140.006      2671.9684      2671.9684    
     90000  -10439.143     -10439.143     -10519.961     -10519.961      312.77252      312.77252      27153.536      27153.536      1857.6836      1857.6836    
Loop time of 49.5839 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.743 ns/day, 13.773 hours/ns, 20.168 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.502     | 49.502     | 49.502     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014923   | 0.014923   | 0.014923   |   0.0 |  0.03
Output  | 4.4644e-05 | 4.4644e-05 | 4.4644e-05 |   0.0 |  0.00
Modify  | 0.06193    | 0.06193    | 0.06193    |   0.0 |  0.12
Other   |            | 0.005278   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223874 ave      223874 max      223874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223874
Ave neighs/atom = 111.937
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.338321826377, Press = 1.41046066020272
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     90000  -10439.143     -10439.143     -10519.961     -10519.961      312.77252      312.77252      27153.536      27153.536      1857.6836      1857.6836    
     91000  -10435.471     -10435.471     -10516.771     -10516.771      314.63985      314.63985      27170.43       27170.43       1383.3676      1383.3676    
Loop time of 49.6102 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.781 hours/ns, 20.157 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    | 49.528     | 49.528     | 49.528     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01489    | 0.01489    | 0.01489    |   0.0 |  0.03
Output  | 3.5727e-05 | 3.5727e-05 | 3.5727e-05 |   0.0 |  0.00
Modify  | 0.061887   | 0.061887   | 0.061887   |   0.0 |  0.12
Other   |            | 0.005296   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223846 ave      223846 max      223846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223846
Ave neighs/atom = 111.923
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.333947705389, Press = 1.62222195862716
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     91000  -10435.471     -10435.471     -10516.771     -10516.771      314.63985      314.63985      27170.43       27170.43       1383.3676      1383.3676    
     92000  -10440.208     -10440.208     -10518.559     -10518.559      303.22646      303.22646      27174.468      27174.468      755.9177       755.9177     
Loop time of 49.5884 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.775 hours/ns, 20.166 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    | 49.506     | 49.506     | 49.506     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014941   | 0.014941   | 0.014941   |   0.0 |  0.03
Output  | 3.5387e-05 | 3.5387e-05 | 3.5387e-05 |   0.0 |  0.00
Modify  | 0.06193    | 0.06193    | 0.06193    |   0.0 |  0.12
Other   |            | 0.005282   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223810 ave      223810 max      223810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223810
Ave neighs/atom = 111.905
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.35136569773, Press = 1.67422509391906
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     92000  -10440.208     -10440.208     -10518.559     -10518.559      303.22646      303.22646      27174.468      27174.468      755.9177       755.9177     
     93000  -10437.667     -10437.667     -10517.484     -10517.484      308.90157      308.90157      27188.355      27188.355      145.92087      145.92087    
Loop time of 49.6147 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.782 hours/ns, 20.155 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    | 49.533     | 49.533     | 49.533     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014964   | 0.014964   | 0.014964   |   0.0 |  0.03
Output  | 3.6037e-05 | 3.6037e-05 | 3.6037e-05 |   0.0 |  0.00
Modify  | 0.061941   | 0.061941   | 0.061941   |   0.0 |  0.12
Other   |            | 0.005258   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223832 ave      223832 max      223832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223832
Ave neighs/atom = 111.916
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.362451749845, Press = 1.71456180420234
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -10437.667     -10437.667     -10517.484     -10517.484      308.90157      308.90157      27188.355      27188.355      145.92087      145.92087    
     94000  -10441.385     -10441.385     -10521.388     -10521.388      309.6217       309.6217       27213.749      27213.749     -1698.6249     -1698.6249    
Loop time of 49.6346 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.787 hours/ns, 20.147 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    | 49.552     | 49.552     | 49.552     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014988   | 0.014988   | 0.014988   |   0.0 |  0.03
Output  | 3.4996e-05 | 3.4996e-05 | 3.4996e-05 |   0.0 |  0.00
Modify  | 0.061886   | 0.061886   | 0.061886   |   0.0 |  0.12
Other   |            | 0.005193   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223796 ave      223796 max      223796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223796
Ave neighs/atom = 111.898
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.334546838485, Press = 2.14855067461669
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -10441.385     -10441.385     -10521.388     -10521.388      309.6217       309.6217       27213.749      27213.749     -1698.6249     -1698.6249    
     95000  -10436.731     -10436.731     -10518.456     -10518.456      316.28393      316.28393      27239.915      27239.915     -2763.1137     -2763.1137    
Loop time of 49.7175 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.738 ns/day, 13.810 hours/ns, 20.114 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    | 49.635     | 49.635     | 49.635     |   0.0 | 99.84
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014924   | 0.014924   | 0.014924   |   0.0 |  0.03
Output  | 2.2112e-05 | 2.2112e-05 | 2.2112e-05 |   0.0 |  0.00
Modify  | 0.061845   | 0.061845   | 0.061845   |   0.0 |  0.12
Other   |            | 0.005228   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223812 ave      223812 max      223812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223812
Ave neighs/atom = 111.906
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.322129227585, Press = 1.85331912710035
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -10436.731     -10436.731     -10518.456     -10518.456      316.28393      316.28393      27239.915      27239.915     -2763.1137     -2763.1137    
     96000  -10439.171     -10439.171     -10520.739     -10520.739      315.67729      315.67729      27216.294      27216.294     -1693.0475     -1693.0475    
Loop time of 49.6639 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.796 hours/ns, 20.135 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    | 49.582     | 49.582     | 49.582     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014958   | 0.014958   | 0.014958   |   0.0 |  0.03
Output  | 3.715e-05  | 3.715e-05  | 3.715e-05  |   0.0 |  0.00
Modify  | 0.061853   | 0.061853   | 0.061853   |   0.0 |  0.12
Other   |            | 0.005216   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223770 ave      223770 max      223770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223770
Ave neighs/atom = 111.885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.323450545565, Press = 1.3032439006736
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -10439.171     -10439.171     -10520.739     -10520.739      315.67729      315.67729      27216.294      27216.294     -1693.0475     -1693.0475    
     97000  -10439.062     -10439.062     -10519.708     -10519.708      312.10818      312.10818      27208.544      27208.544     -1139.9875     -1139.9875    
Loop time of 49.6258 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.785 hours/ns, 20.151 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.543     | 49.543     | 49.543     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015012   | 0.015012   | 0.015012   |   0.0 |  0.03
Output  | 5.1717e-05 | 5.1717e-05 | 5.1717e-05 |   0.0 |  0.00
Modify  | 0.062106   | 0.062106   | 0.062106   |   0.0 |  0.13
Other   |            | 0.005381   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223842 ave      223842 max      223842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223842
Ave neighs/atom = 111.921
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.317905804569, Press = 1.048867354589
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     97000  -10439.062     -10439.062     -10519.708     -10519.708      312.10818      312.10818      27208.544      27208.544     -1139.9875     -1139.9875    
     98000  -10435.948     -10435.948     -10517.786     -10517.786      316.72382      316.72382      27207.162      27207.162     -790.81416     -790.81416    
Loop time of 49.709 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.738 ns/day, 13.808 hours/ns, 20.117 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    | 49.626     | 49.626     | 49.626     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015006   | 0.015006   | 0.015006   |   0.0 |  0.03
Output  | 5.0906e-05 | 5.0906e-05 | 5.0906e-05 |   0.0 |  0.00
Modify  | 0.062161   | 0.062161   | 0.062161   |   0.0 |  0.13
Other   |            | 0.005482   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223826 ave      223826 max      223826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223826
Ave neighs/atom = 111.913
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.332875706097, Press = 0.829033215218805
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -10435.948     -10435.948     -10517.786     -10517.786      316.72382      316.72382      27207.162      27207.162     -790.81416     -790.81416    
     99000  -10440.513     -10440.513     -10519.481     -10519.481      305.61249      305.61249      27188.87       27188.87      -87.541053     -87.541053    
Loop time of 49.6355 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.788 hours/ns, 20.147 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    | 49.553     | 49.553     | 49.553     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015061   | 0.015061   | 0.015061   |   0.0 |  0.03
Output  | 4.6758e-05 | 4.6758e-05 | 4.6758e-05 |   0.0 |  0.00
Modify  | 0.062148   | 0.062148   | 0.062148   |   0.0 |  0.13
Other   |            | 0.005386   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223860 ave      223860 max      223860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223860
Ave neighs/atom = 111.93
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.342512981451, Press = 0.548650808590397
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -10440.513     -10440.513     -10519.481     -10519.481      305.61249      305.61249      27188.87       27188.87      -87.541053     -87.541053    
    100000  -10433.701     -10433.701     -10518.262     -10518.262      327.25931      327.25931      27167.977      27167.977      1433.0032      1433.0032    
Loop time of 49.5772 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.743 ns/day, 13.771 hours/ns, 20.171 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    | 49.495     | 49.495     | 49.495     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014987   | 0.014987   | 0.014987   |   0.0 |  0.03
Output  | 4.9994e-05 | 4.9994e-05 | 4.9994e-05 |   0.0 |  0.00
Modify  | 0.062183   | 0.062183   | 0.062183   |   0.0 |  0.13
Other   |            | 0.005374   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223836 ave      223836 max      223836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223836
Ave neighs/atom = 111.918
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.363366151259, Press = 0.406421929103664
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    100000  -10433.701     -10433.701     -10518.262     -10518.262      327.25931      327.25931      27167.977      27167.977      1433.0032      1433.0032    
    101000  -10437.194     -10437.194     -10519.452     -10519.452      318.3478       318.3478       27110.471      27110.471      4489.3907      4489.3907    
Loop time of 49.5979 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.777 hours/ns, 20.162 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    | 49.515     | 49.515     | 49.515     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015004   | 0.015004   | 0.015004   |   0.0 |  0.03
Output  | 2.6059e-05 | 2.6059e-05 | 2.6059e-05 |   0.0 |  0.00
Modify  | 0.062211   | 0.062211   | 0.062211   |   0.0 |  0.13
Other   |            | 0.005426   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223814 ave      223814 max      223814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223814
Ave neighs/atom = 111.907
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.369141450311, Press = 0.701667010759984
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -10437.194     -10437.194     -10519.452     -10519.452      318.3478       318.3478       27110.471      27110.471      4489.3907      4489.3907    
    102000  -10438.628     -10438.628     -10519.734     -10519.734      313.88882      313.88882      27151.542      27151.542      2165.6917      2165.6917    
Loop time of 49.6118 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.781 hours/ns, 20.157 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    | 49.529     | 49.529     | 49.529     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015062   | 0.015062   | 0.015062   |   0.0 |  0.03
Output  | 5.4412e-05 | 5.4412e-05 | 5.4412e-05 |   0.0 |  0.00
Modify  | 0.062229   | 0.062229   | 0.062229   |   0.0 |  0.13
Other   |            | 0.005371   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223824 ave      223824 max      223824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223824
Ave neighs/atom = 111.912
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.368243802225, Press = 1.2958242271429
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    102000  -10438.628     -10438.628     -10519.734     -10519.734      313.88882      313.88882      27151.542      27151.542      2165.6917      2165.6917    
    103000  -10439.355     -10439.355     -10518.959     -10518.959      308.07548      308.07548      27167.435      27167.435      1196.4905      1196.4905    
Loop time of 49.6364 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.788 hours/ns, 20.147 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    | 49.554     | 49.554     | 49.554     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015035   | 0.015035   | 0.015035   |   0.0 |  0.03
Output  | 5.289e-05  | 5.289e-05  | 5.289e-05  |   0.0 |  0.00
Modify  | 0.062109   | 0.062109   | 0.062109   |   0.0 |  0.13
Other   |            | 0.00543    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223812 ave      223812 max      223812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223812
Ave neighs/atom = 111.906
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.363804966417, Press = 1.46558722815148
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    103000  -10439.355     -10439.355     -10518.959     -10518.959      308.07548      308.07548      27167.435      27167.435      1196.4905      1196.4905    
    104000  -10441.525     -10441.525     -10519.456     -10519.456      301.59881      301.59881      27174.076      27174.076      715.37852      715.37852    
Loop time of 49.6582 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.794 hours/ns, 20.138 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    | 49.576     | 49.576     | 49.576     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014977   | 0.014977   | 0.014977   |   0.0 |  0.03
Output  | 4.6597e-05 | 4.6597e-05 | 4.6597e-05 |   0.0 |  0.00
Modify  | 0.062201   | 0.062201   | 0.062201   |   0.0 |  0.13
Other   |            | 0.0054     |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223844 ave      223844 max      223844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223844
Ave neighs/atom = 111.922
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.368353702191, Press = 1.5649358390743
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    104000  -10441.525     -10441.525     -10519.456     -10519.456      301.59881      301.59881      27174.076      27174.076      715.37852      715.37852    
    105000  -10438.018     -10438.018     -10519.817     -10519.817      316.57251      316.57251      27195.747      27195.747     -452.1784      -452.1784     
Loop time of 49.6621 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.795 hours/ns, 20.136 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    | 49.579     | 49.579     | 49.579     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014964   | 0.014964   | 0.014964   |   0.0 |  0.03
Output  | 5.1487e-05 | 5.1487e-05 | 5.1487e-05 |   0.0 |  0.00
Modify  | 0.062197   | 0.062197   | 0.062197   |   0.0 |  0.13
Other   |            | 0.005401   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223866 ave      223866 max      223866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223866
Ave neighs/atom = 111.933
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.376263524334, Press = 1.62512306595954
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    105000  -10438.018     -10438.018     -10519.817     -10519.817      316.57251      316.57251      27195.747      27195.747     -452.1784      -452.1784     
    106000  -10436.501     -10436.501     -10517.111     -10517.111      311.96729      311.96729      27235.05       27235.05      -2450.8068     -2450.8068    
Loop time of 49.5705 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.743 ns/day, 13.770 hours/ns, 20.173 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    | 49.488     | 49.488     | 49.488     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015147   | 0.015147   | 0.015147   |   0.0 |  0.03
Output  | 4.6697e-05 | 4.6697e-05 | 4.6697e-05 |   0.0 |  0.00
Modify  | 0.062188   | 0.062188   | 0.062188   |   0.0 |  0.13
Other   |            | 0.005394   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223866 ave      223866 max      223866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223866
Ave neighs/atom = 111.933
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.38796173386, Press = 1.83837357123486
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    106000  -10436.501     -10436.501     -10517.111     -10517.111      311.96729      311.96729      27235.05       27235.05      -2450.8068     -2450.8068    
    107000  -10439.473     -10439.473     -10519.403     -10519.403      309.33729      309.33729      27241.331      27241.331     -3195.5589     -3195.5589    
Loop time of 49.4951 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.746 ns/day, 13.749 hours/ns, 20.204 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    | 49.413     | 49.413     | 49.413     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015016   | 0.015016   | 0.015016   |   0.0 |  0.03
Output  | 2.4816e-05 | 2.4816e-05 | 2.4816e-05 |   0.0 |  0.00
Modify  | 0.062121   | 0.062121   | 0.062121   |   0.0 |  0.13
Other   |            | 0.00537    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223778 ave      223778 max      223778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223778
Ave neighs/atom = 111.889
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.415119352098, Press = 1.44178000740128
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    107000  -10439.473     -10439.473     -10519.403     -10519.403      309.33729      309.33729      27241.331      27241.331     -3195.5589     -3195.5589    
    108000  -10435.993     -10435.993     -10518.45      -10518.45       319.1146       319.1146       27231.183      27231.183     -2277.9672     -2277.9672    
Loop time of 49.5165 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.745 ns/day, 13.755 hours/ns, 20.195 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.434     | 49.434     | 49.434     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015005   | 0.015005   | 0.015005   |   0.0 |  0.03
Output  | 5.304e-05  | 5.304e-05  | 5.304e-05  |   0.0 |  0.00
Modify  | 0.062164   | 0.062164   | 0.062164   |   0.0 |  0.13
Other   |            | 0.005419   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223790 ave      223790 max      223790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223790
Ave neighs/atom = 111.895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.421537618799, Press = 1.06253763783168
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    108000  -10435.993     -10435.993     -10518.45      -10518.45       319.1146       319.1146       27231.183      27231.183     -2277.9672     -2277.9672    
    109000  -10441.201     -10441.201     -10521.463     -10521.463      310.61998      310.61998      27216.21       27216.21      -1917.9521     -1917.9521    
Loop time of 49.5298 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.744 ns/day, 13.758 hours/ns, 20.190 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.447     | 49.447     | 49.447     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015057   | 0.015057   | 0.015057   |   0.0 |  0.03
Output  | 4.8672e-05 | 4.8672e-05 | 4.8672e-05 |   0.0 |  0.00
Modify  | 0.062239   | 0.062239   | 0.062239   |   0.0 |  0.13
Other   |            | 0.005443   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223742 ave      223742 max      223742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223742
Ave neighs/atom = 111.871
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.418002362336, Press = 0.815744870245116
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    109000  -10441.201     -10441.201     -10521.463     -10521.463      310.61998      310.61998      27216.21       27216.21      -1917.9521     -1917.9521    
    110000  -10436.663     -10436.663     -10520.672     -10520.672      325.12458      325.12458      27207.273      27207.273     -1077.8618     -1077.8618    
Loop time of 49.6822 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.801 hours/ns, 20.128 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    | 49.599     | 49.599     | 49.599     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015092   | 0.015092   | 0.015092   |   0.0 |  0.03
Output  | 5.2519e-05 | 5.2519e-05 | 5.2519e-05 |   0.0 |  0.00
Modify  | 0.06222    | 0.06222    | 0.06222    |   0.0 |  0.13
Other   |            | 0.005399   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223862 ave      223862 max      223862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223862
Ave neighs/atom = 111.931
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.395827964805, Press = 0.612806749929457
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    110000  -10436.663     -10436.663     -10520.672     -10520.672      325.12458      325.12458      27207.273      27207.273     -1077.8618     -1077.8618    
    111000  -10442.418     -10442.418     -10521.843     -10521.843      307.38538      307.38538      27183.698      27183.698     -54.621536     -54.621536    
Loop time of 49.6491 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.791 hours/ns, 20.141 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.566     | 49.566     | 49.566     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015008   | 0.015008   | 0.015008   |   0.0 |  0.03
Output  | 5.3291e-05 | 5.3291e-05 | 5.3291e-05 |   0.0 |  0.00
Modify  | 0.06213    | 0.06213    | 0.06213    |   0.0 |  0.13
Other   |            | 0.005407   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223828 ave      223828 max      223828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223828
Ave neighs/atom = 111.914
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.37109328981, Press = 0.638194457560496
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    111000  -10442.418     -10442.418     -10521.843     -10521.843      307.38538      307.38538      27183.698      27183.698     -54.621536     -54.621536    
    112000  -10436.985     -10436.985     -10517.572     -10517.572      311.8791       311.8791       27178.713      27178.713      690.0033       690.0033     
Loop time of 49.6802 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.800 hours/ns, 20.129 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.597     | 49.597     | 49.597     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015135   | 0.015135   | 0.015135   |   0.0 |  0.03
Output  | 4.219e-05  | 4.219e-05  | 4.219e-05  |   0.0 |  0.00
Modify  | 0.062327   | 0.062327   | 0.062327   |   0.0 |  0.13
Other   |            | 0.005423   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223884 ave      223884 max      223884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223884
Ave neighs/atom = 111.942
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.358895397628, Press = 0.903247665243417
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    112000  -10436.985     -10436.985     -10517.572     -10517.572      311.8791       311.8791       27178.713      27178.713      690.0033       690.0033     
    113000  -10440.744     -10440.744     -10520.315     -10520.315      307.94796      307.94796      27171.936      27171.936      801.08957      801.08957    
Loop time of 49.6956 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.804 hours/ns, 20.122 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.613     | 49.613     | 49.613     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015071   | 0.015071   | 0.015071   |   0.0 |  0.03
Output  | 2.6059e-05 | 2.6059e-05 | 2.6059e-05 |   0.0 |  0.00
Modify  | 0.0623     | 0.0623     | 0.0623     |   0.0 |  0.13
Other   |            | 0.005386   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223810 ave      223810 max      223810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223810
Ave neighs/atom = 111.905
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.338339475815, Press = 1.03422924510009
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    113000  -10440.744     -10440.744     -10520.315     -10520.315      307.94796      307.94796      27171.936      27171.936      801.08957      801.08957    
    114000  -10434.573     -10434.573     -10516.791     -10516.791      318.19412      318.19412      27181.872      27181.872      569.86446      569.86446    
Loop time of 49.5116 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.745 ns/day, 13.753 hours/ns, 20.197 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.429     | 49.429     | 49.429     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015101   | 0.015101   | 0.015101   |   0.0 |  0.03
Output  | 5.2027e-05 | 5.2027e-05 | 5.2027e-05 |   0.0 |  0.00
Modify  | 0.06229    | 0.06229    | 0.06229    |   0.0 |  0.13
Other   |            | 0.005406   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223838 ave      223838 max      223838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223838
Ave neighs/atom = 111.919
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.337248490859, Press = 1.1356663865
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    114000  -10434.573     -10434.573     -10516.791     -10516.791      318.19412      318.19412      27181.872      27181.872      569.86446      569.86446    
    115000  -10439.826     -10439.826     -10520.405     -10520.405      311.8508       311.8508       27175.379      27175.379      587.62346      587.62346    
Loop time of 49.6045 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.779 hours/ns, 20.159 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.522     | 49.522     | 49.522     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015071   | 0.015071   | 0.015071   |   0.0 |  0.03
Output  | 5.2569e-05 | 5.2569e-05 | 5.2569e-05 |   0.0 |  0.00
Modify  | 0.062322   | 0.062322   | 0.062322   |   0.0 |  0.13
Other   |            | 0.005385   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223784 ave      223784 max      223784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223784
Ave neighs/atom = 111.892
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.356671080733, Press = 1.27692963773297
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    115000  -10439.826     -10439.826     -10520.405     -10520.405      311.8508       311.8508       27175.379      27175.379      587.62346      587.62346    
    116000  -10442.39      -10442.39      -10521.38      -10521.38       305.70024      305.70024      27181.905      27181.905      19.429006      19.429006    
Loop time of 49.5786 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.743 ns/day, 13.772 hours/ns, 20.170 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.496     | 49.496     | 49.496     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015154   | 0.015154   | 0.015154   |   0.0 |  0.03
Output  | 5.9532e-05 | 5.9532e-05 | 5.9532e-05 |   0.0 |  0.00
Modify  | 0.062311   | 0.062311   | 0.062311   |   0.0 |  0.13
Other   |            | 0.005437   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223848 ave      223848 max      223848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223848
Ave neighs/atom = 111.924
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.353731148946, Press = 1.59312260716763
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    116000  -10442.39      -10442.39      -10521.38      -10521.38       305.70024      305.70024      27181.905      27181.905      19.429006      19.429006    
    117000  -10437.688     -10437.688     -10519.125     -10519.125      315.17069      315.17069      27207.564      27207.564     -1026.7704     -1026.7704    
Loop time of 49.7904 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.735 ns/day, 13.831 hours/ns, 20.084 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.707     | 49.707     | 49.707     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015087   | 0.015087   | 0.015087   |   0.0 |  0.03
Output  | 4.4283e-05 | 4.4283e-05 | 4.4283e-05 |   0.0 |  0.00
Modify  | 0.062417   | 0.062417   | 0.062417   |   0.0 |  0.13
Other   |            | 0.005415   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223854 ave      223854 max      223854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223854
Ave neighs/atom = 111.927
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.323249865932, Press = 1.65133191471212
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    117000  -10437.688     -10437.688     -10519.125     -10519.125      315.17069      315.17069      27207.564      27207.564     -1026.7704     -1026.7704    
    118000  -10440.545     -10440.545     -10518.337     -10518.337      301.06365      301.06365      27218.98       27218.98      -1737.4091     -1737.4091    
Loop time of 49.878 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.732 ns/day, 13.855 hours/ns, 20.049 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.795     | 49.795     | 49.795     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015129   | 0.015129   | 0.015129   |   0.0 |  0.03
Output  | 2.5177e-05 | 2.5177e-05 | 2.5177e-05 |   0.0 |  0.00
Modify  | 0.062278   | 0.062278   | 0.062278   |   0.0 |  0.12
Other   |            | 0.005414   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223802 ave      223802 max      223802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223802
Ave neighs/atom = 111.901
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.319655621582, Press = 1.34213810150079
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    118000  -10440.545     -10440.545     -10518.337     -10518.337      301.06365      301.06365      27218.98       27218.98      -1737.4091     -1737.4091    
    119000  -10435.612     -10435.612     -10517.866     -10517.866      318.3328       318.3328       27224.048      27224.048     -1813.3821     -1813.3821    
Loop time of 49.9327 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.730 ns/day, 13.870 hours/ns, 20.027 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.849     | 49.849     | 49.849     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015171   | 0.015171   | 0.015171   |   0.0 |  0.03
Output  | 5.5654e-05 | 5.5654e-05 | 5.5654e-05 |   0.0 |  0.00
Modify  | 0.062573   | 0.062573   | 0.062573   |   0.0 |  0.13
Other   |            | 0.005479   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223782 ave      223782 max      223782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223782
Ave neighs/atom = 111.891
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.31530793648, Press = 1.01633665819682
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    119000  -10435.612     -10435.612     -10517.866     -10517.866      318.3328       318.3328       27224.048      27224.048     -1813.3821     -1813.3821    
    120000  -10439.384     -10439.384     -10520.434     -10520.434      313.67274      313.67274      27204.016      27204.016     -938.03883     -938.03883    
Loop time of 49.909 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.731 ns/day, 13.864 hours/ns, 20.036 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.826     | 49.826     | 49.826     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0152     | 0.0152     | 0.0152     |   0.0 |  0.03
Output  | 5.0755e-05 | 5.0755e-05 | 5.0755e-05 |   0.0 |  0.00
Modify  | 0.062574   | 0.062574   | 0.062574   |   0.0 |  0.13
Other   |            | 0.005506   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223794 ave      223794 max      223794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223794
Ave neighs/atom = 111.897
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.319388055003, Press = 0.905088260159013
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    120000  -10439.384     -10439.384     -10520.434     -10520.434      313.67274      313.67274      27204.016      27204.016     -938.03883     -938.03883    
    121000  -10437.516     -10437.516     -10519.92      -10519.92       318.91034      318.91034      27193.949      27193.949     -497.03835     -497.03835    
Loop time of 49.9399 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.730 ns/day, 13.872 hours/ns, 20.024 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.857     | 49.857     | 49.857     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015071   | 0.015071   | 0.015071   |   0.0 |  0.03
Output  | 5.0945e-05 | 5.0945e-05 | 5.0945e-05 |   0.0 |  0.00
Modify  | 0.062491   | 0.062491   | 0.062491   |   0.0 |  0.13
Other   |            | 0.005443   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223788 ave      223788 max      223788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223788
Ave neighs/atom = 111.894
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.311629908475, Press = 0.842283028155116
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    121000  -10437.516     -10437.516     -10519.92      -10519.92       318.91034      318.91034      27193.949      27193.949     -497.03835     -497.03835    
    122000  -10439.823     -10439.823     -10518.663     -10518.663      305.12133      305.12133      27184.006      27184.006      169.18956      169.18956    
Loop time of 49.8012 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.735 ns/day, 13.834 hours/ns, 20.080 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.718     | 49.718     | 49.718     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015112   | 0.015112   | 0.015112   |   0.0 |  0.03
Output  | 4.6578e-05 | 4.6578e-05 | 4.6578e-05 |   0.0 |  0.00
Modify  | 0.062564   | 0.062564   | 0.062564   |   0.0 |  0.13
Other   |            | 0.005445   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223794 ave      223794 max      223794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223794
Ave neighs/atom = 111.897
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.331465509056, Press = 0.852830264731445
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    122000  -10439.823     -10439.823     -10518.663     -10518.663      305.12133      305.12133      27184.006      27184.006      169.18956      169.18956    
    123000  -10437.899     -10437.899     -10518.554     -10518.554      312.14336      312.14336      27171.739      27171.739      1078.7497      1078.7497    
Loop time of 49.7394 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.737 ns/day, 13.816 hours/ns, 20.105 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.656     | 49.656     | 49.656     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015106   | 0.015106   | 0.015106   |   0.0 |  0.03
Output  | 5.0214e-05 | 5.0214e-05 | 5.0214e-05 |   0.0 |  0.00
Modify  | 0.062521   | 0.062521   | 0.062521   |   0.0 |  0.13
Other   |            | 0.005431   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223804 ave      223804 max      223804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223804
Ave neighs/atom = 111.902
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.333557503538, Press = 0.750579483736299
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    123000  -10437.899     -10437.899     -10518.554     -10518.554      312.14336      312.14336      27171.739      27171.739      1078.7497      1078.7497    
    124000  -10440.096     -10440.096     -10521.305     -10521.305      314.28866      314.28866      27143.199      27143.199      2473.3686      2473.3686    
Loop time of 49.7715 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.736 ns/day, 13.825 hours/ns, 20.092 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.688     | 49.688     | 49.688     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015158   | 0.015158   | 0.015158   |   0.0 |  0.03
Output  | 2.4587e-05 | 2.4587e-05 | 2.4587e-05 |   0.0 |  0.00
Modify  | 0.06239    | 0.06239    | 0.06239    |   0.0 |  0.13
Other   |            | 0.005392   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223826 ave      223826 max      223826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223826
Ave neighs/atom = 111.913
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.307718854304, Press = 0.788847072093162
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    124000  -10440.096     -10440.096     -10521.305     -10521.305      314.28866      314.28866      27143.199      27143.199      2473.3686      2473.3686    
    125000  -10440.862     -10440.862     -10523.368     -10523.368      319.30649      319.30649      27128.33       27128.33       3115.8417      3115.8417    
Loop time of 49.6771 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.799 hours/ns, 20.130 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.594     | 49.594     | 49.594     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015071   | 0.015071   | 0.015071   |   0.0 |  0.03
Output  | 5.0254e-05 | 5.0254e-05 | 5.0254e-05 |   0.0 |  0.00
Modify  | 0.062303   | 0.062303   | 0.062303   |   0.0 |  0.13
Other   |            | 0.005447   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223852 ave      223852 max      223852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223852
Ave neighs/atom = 111.926
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.306871120125, Press = 1.10364976396301
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    125000  -10440.862     -10440.862     -10523.368     -10523.368      319.30649      319.30649      27128.33       27128.33       3115.8417      3115.8417    
    126000  -10438.123     -10438.123     -10518.61      -10518.61       311.49455      311.49455      27160.437      27160.437      1753.0927      1753.0927    
Loop time of 49.6097 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.780 hours/ns, 20.157 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.527     | 49.527     | 49.527     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01508    | 0.01508    | 0.01508    |   0.0 |  0.03
Output  | 5.1888e-05 | 5.1888e-05 | 5.1888e-05 |   0.0 |  0.00
Modify  | 0.062307   | 0.062307   | 0.062307   |   0.0 |  0.13
Other   |            | 0.00543    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223892 ave      223892 max      223892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223892
Ave neighs/atom = 111.946
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.309942000316, Press = 1.18727524714015
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    126000  -10438.123     -10438.123     -10518.61      -10518.61       311.49455      311.49455      27160.437      27160.437      1753.0927      1753.0927    
    127000  -10437.386     -10437.386     -10519.652     -10519.652      318.37895      318.37895      27184.048      27184.048      280.84288      280.84288    
Loop time of 49.681 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.739 ns/day, 13.800 hours/ns, 20.128 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    | 49.598     | 49.598     | 49.598     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015018   | 0.015018   | 0.015018   |   0.0 |  0.03
Output  | 4.7679e-05 | 4.7679e-05 | 4.7679e-05 |   0.0 |  0.00
Modify  | 0.062188   | 0.062188   | 0.062188   |   0.0 |  0.13
Other   |            | 0.005402   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223848 ave      223848 max      223848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223848
Ave neighs/atom = 111.924
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.294491979844, Press = 1.11376621955071
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    127000  -10437.386     -10437.386     -10519.652     -10519.652      318.37895      318.37895      27184.048      27184.048      280.84288      280.84288    
    128000  -10437.476     -10437.476     -10520         -10520          319.37483      319.37483      27198.685      27198.685     -581.29504     -581.29504    
Loop time of 49.6015 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.778 hours/ns, 20.161 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.519     | 49.519     | 49.519     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015035   | 0.015035   | 0.015035   |   0.0 |  0.03
Output  | 8.2796e-05 | 8.2796e-05 | 8.2796e-05 |   0.0 |  0.00
Modify  | 0.062355   | 0.062355   | 0.062355   |   0.0 |  0.13
Other   |            | 0.005437   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223802 ave      223802 max      223802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223802
Ave neighs/atom = 111.901
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.286493273448, Press = 1.08489917222637
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    128000  -10437.476     -10437.476     -10520         -10520          319.37483      319.37483      27198.685      27198.685     -581.29504     -581.29504    
    129000  -10436.841     -10436.841     -10518.89      -10518.89       317.53718      317.53718      27213.677      27213.677     -1466.9303     -1466.9303    
Loop time of 49.5459 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.744 ns/day, 13.763 hours/ns, 20.183 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.463     | 49.463     | 49.463     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.015081   | 0.015081   | 0.015081   |   0.0 |  0.03
Output  | 5.1567e-05 | 5.1567e-05 | 5.1567e-05 |   0.0 |  0.00
Modify  | 0.062163   | 0.062163   | 0.062163   |   0.0 |  0.13
Other   |            | 0.005406   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223830 ave      223830 max      223830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223830
Ave neighs/atom = 111.915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.279969224482, Press = 1.10938012439083
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    129000  -10436.841     -10436.841     -10518.89      -10518.89       317.53718      317.53718      27213.677      27213.677     -1466.9303     -1466.9303    
    130000  -10436.725     -10436.725     -10518.722     -10518.722      317.33578      317.33578      27248.769      27248.769     -3370.1906     -3370.1906    
Loop time of 49.4965 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.746 ns/day, 13.749 hours/ns, 20.203 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.414     | 49.414     | 49.414     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01502    | 0.01502    | 0.01502    |   0.0 |  0.03
Output  | 2.5398e-05 | 2.5398e-05 | 2.5398e-05 |   0.0 |  0.00
Modify  | 0.062068   | 0.062068   | 0.062068   |   0.0 |  0.13
Other   |            | 0.005388   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223786 ave      223786 max      223786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223786
Ave neighs/atom = 111.893
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.288504923686, Press = 0.939282041088946
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    130000  -10436.725     -10436.725     -10518.722     -10518.722      317.33578      317.33578      27248.769      27248.769     -3370.1906     -3370.1906    
    131000  -10434.172     -10434.172     -10515.561     -10515.561      314.9839       314.9839       27243.471      27243.471     -2777.6455     -2777.6455    
Loop time of 49.5617 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.743 ns/day, 13.767 hours/ns, 20.177 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    | 49.479     | 49.479     | 49.479     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014992   | 0.014992   | 0.014992   |   0.0 |  0.03
Output  | 5.0515e-05 | 5.0515e-05 | 5.0515e-05 |   0.0 |  0.00
Modify  | 0.062161   | 0.062161   | 0.062161   |   0.0 |  0.13
Other   |            | 0.00541    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223750 ave      223750 max      223750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223750
Ave neighs/atom = 111.875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.293113329618, Press = 0.65365966462267
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    131000  -10434.172     -10434.172     -10515.561     -10515.561      314.9839       314.9839       27243.471      27243.471     -2777.6455     -2777.6455    
    132000  -10438.981     -10438.981     -10520.284     -10520.284      314.64958      314.64958      27208.026      27208.026     -1163.7857     -1163.7857    
Loop time of 49.6067 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.780 hours/ns, 20.159 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.524     | 49.524     | 49.524     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014785   | 0.014785   | 0.014785   |   0.0 |  0.03
Output  | 4.8741e-05 | 4.8741e-05 | 4.8741e-05 |   0.0 |  0.00
Modify  | 0.06205    | 0.06205    | 0.06205    |   0.0 |  0.13
Other   |            | 0.0054     |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223758 ave      223758 max      223758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223758
Ave neighs/atom = 111.879
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.30963826139, Press = 0.607589790546459
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    132000  -10438.981     -10438.981     -10520.284     -10520.284      314.64958      314.64958      27208.026      27208.026     -1163.7857     -1163.7857    
    133000  -10435.6       -10435.6       -10519.165     -10519.165      323.40455      323.40455      27195.909      27195.909     -268.59028     -268.59028    
Loop time of 49.6641 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.796 hours/ns, 20.135 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    | 49.582     | 49.582     | 49.582     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014815   | 0.014815   | 0.014815   |   0.0 |  0.03
Output  | 4.6498e-05 | 4.6498e-05 | 4.6498e-05 |   0.0 |  0.00
Modify  | 0.062081   | 0.062081   | 0.062081   |   0.0 |  0.13
Other   |            | 0.005412   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223796 ave      223796 max      223796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223796
Ave neighs/atom = 111.898
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.328064110189, Press = 0.675661142215824
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    133000  -10435.6       -10435.6       -10519.165     -10519.165      323.40455      323.40455      27195.909      27195.909     -268.59028     -268.59028    
    134000  -10437.206     -10437.206     -10518.154     -10518.154      313.27632      313.27632      27179.885      27179.885      666.83661      666.83661    
Loop time of 49.5301 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.744 ns/day, 13.758 hours/ns, 20.190 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.448     | 49.448     | 49.448     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014888   | 0.014888   | 0.014888   |   0.0 |  0.03
Output  | 4.8531e-05 | 4.8531e-05 | 4.8531e-05 |   0.0 |  0.00
Modify  | 0.062008   | 0.062008   | 0.062008   |   0.0 |  0.13
Other   |            | 0.005388   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223852 ave      223852 max      223852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223852
Ave neighs/atom = 111.926
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.323499621253, Press = 0.70246252030406
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    134000  -10437.206     -10437.206     -10518.154     -10518.154      313.27632      313.27632      27179.885      27179.885      666.83661      666.83661    
    135000  -10439.968     -10439.968     -10519.725     -10519.725      308.66837      308.66837      27138.108      27138.108      2885.9985      2885.9985    
Loop time of 49.6196 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.783 hours/ns, 20.153 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.537     | 49.537     | 49.537     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014809   | 0.014809   | 0.014809   |   0.0 |  0.03
Output  | 4.2309e-05 | 4.2309e-05 | 4.2309e-05 |   0.0 |  0.00
Modify  | 0.062093   | 0.062093   | 0.062093   |   0.0 |  0.13
Other   |            | 0.005409   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223792 ave      223792 max      223792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223792
Ave neighs/atom = 111.896
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.326601483766, Press = 0.649716831646936
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    135000  -10439.968     -10439.968     -10519.725     -10519.725      308.66837      308.66837      27138.108      27138.108      2885.9985      2885.9985    
    136000  -10438.924     -10438.924     -10519.162     -10519.162      310.52981      310.52981      27121.785      27121.785      3891.9467      3891.9467    
Loop time of 49.5902 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.775 hours/ns, 20.165 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.508     | 49.508     | 49.508     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01477    | 0.01477    | 0.01477    |   0.0 |  0.03
Output  | 2.6339e-05 | 2.6339e-05 | 2.6339e-05 |   0.0 |  0.00
Modify  | 0.062126   | 0.062126   | 0.062126   |   0.0 |  0.13
Other   |            | 0.00539    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223842 ave      223842 max      223842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223842
Ave neighs/atom = 111.921
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.331769313914, Press = 0.940990659714502
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    136000  -10438.924     -10438.924     -10519.162     -10519.162      310.52981      310.52981      27121.785      27121.785      3891.9467      3891.9467    
    137000  -10439.027     -10439.027     -10521.659     -10521.659      319.79339      319.79339      27159.379      27159.379      1527.6271      1527.6271    
Loop time of 49.5661 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.743 ns/day, 13.768 hours/ns, 20.175 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.484     | 49.484     | 49.484     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.01481    | 0.01481    | 0.01481    |   0.0 |  0.03
Output  | 4.7078e-05 | 4.7078e-05 | 4.7078e-05 |   0.0 |  0.00
Modify  | 0.061994   | 0.061994   | 0.061994   |   0.0 |  0.13
Other   |            | 0.005401   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223822 ave      223822 max      223822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223822
Ave neighs/atom = 111.911
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.31598230143, Press = 1.13303131920688
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    137000  -10439.027     -10439.027     -10521.659     -10521.659      319.79339      319.79339      27159.379      27159.379      1527.6271      1527.6271    
    138000  -10440.226     -10440.226     -10521.356     -10521.356      313.98267      313.98267      27174.79       27174.79       619.70122      619.70122    
Loop time of 49.5479 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.744 ns/day, 13.763 hours/ns, 20.182 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.465     | 49.465     | 49.465     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014865   | 0.014865   | 0.014865   |   0.0 |  0.03
Output  | 4.7169e-05 | 4.7169e-05 | 4.7169e-05 |   0.0 |  0.00
Modify  | 0.0621     | 0.0621     | 0.0621     |   0.0 |  0.13
Other   |            | 0.005408   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223870 ave      223870 max      223870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223870
Ave neighs/atom = 111.935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.322090371882, Press = 1.20208822135179
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    138000  -10440.226     -10440.226     -10521.356     -10521.356      313.98267      313.98267      27174.79       27174.79       619.70122      619.70122    
    139000  -10436.389     -10436.389     -10516.893     -10516.893      311.56051      311.56051      27193.117      27193.117      5.1091968      5.1091968    
Loop time of 49.6043 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.779 hours/ns, 20.160 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    | 49.522     | 49.522     | 49.522     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014781   | 0.014781   | 0.014781   |   0.0 |  0.03
Output  | 4.8491e-05 | 4.8491e-05 | 4.8491e-05 |   0.0 |  0.00
Modify  | 0.061942   | 0.061942   | 0.061942   |   0.0 |  0.12
Other   |            | 0.005407   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223858 ave      223858 max      223858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223858
Ave neighs/atom = 111.929
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.328154762824, Press = 1.17384066695699
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    139000  -10436.389     -10436.389     -10516.893     -10516.893      311.56051      311.56051      27193.117      27193.117      5.1091968      5.1091968    
    140000  -10435.958     -10435.958     -10518.237     -10518.237      318.42736      318.42736      27215.383      27215.383     -1221.4926     -1221.4926    
Loop time of 49.6262 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.785 hours/ns, 20.151 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.544     | 49.544     | 49.544     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014832   | 0.014832   | 0.014832   |   0.0 |  0.03
Output  | 4.7479e-05 | 4.7479e-05 | 4.7479e-05 |   0.0 |  0.00
Modify  | 0.06195    | 0.06195    | 0.06195    |   0.0 |  0.12
Other   |            | 0.005434   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223814 ave      223814 max      223814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223814
Ave neighs/atom = 111.907
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.334789390872, Press = 1.41041643027043
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    140000  -10435.958     -10435.958     -10518.237     -10518.237      318.42736      318.42736      27215.383      27215.383     -1221.4926     -1221.4926    
    141000  -10441.572     -10441.572     -10520.478     -10520.478      305.37322      305.37322      27252.465      27252.465     -3730.6856     -3730.6856    
Loop time of 49.6357 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.788 hours/ns, 20.147 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.553     | 49.553     | 49.553     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014773   | 0.014773   | 0.014773   |   0.0 |  0.03
Output  | 3.1248e-05 | 3.1248e-05 | 3.1248e-05 |   0.0 |  0.00
Modify  | 0.062046   | 0.062046   | 0.062046   |   0.0 |  0.13
Other   |            | 0.005418   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223788 ave      223788 max      223788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223788
Ave neighs/atom = 111.894
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.314428634251, Press = 1.37600683994371
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    141000  -10441.572     -10441.572     -10520.478     -10520.478      305.37322      305.37322      27252.465      27252.465     -3730.6856     -3730.6856    
    142000  -10438.222     -10438.222     -10519.338     -10519.338      313.92674      313.92674      27226.64       27226.64      -1988.3519     -1988.3519    
Loop time of 49.6643 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.740 ns/day, 13.796 hours/ns, 20.135 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.582     | 49.582     | 49.582     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014811   | 0.014811   | 0.014811   |   0.0 |  0.03
Output  | 2.5017e-05 | 2.5017e-05 | 2.5017e-05 |   0.0 |  0.00
Modify  | 0.062001   | 0.062001   | 0.062001   |   0.0 |  0.12
Other   |            | 0.00541    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223834 ave      223834 max      223834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223834
Ave neighs/atom = 111.917
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.30605388652, Press = 0.913056655354022
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    142000  -10438.222     -10438.222     -10519.338     -10519.338      313.92674      313.92674      27226.64       27226.64      -1988.3519     -1988.3519    
    143000  -10440.443     -10440.443     -10518.998     -10518.998      304.01605      304.01605      27210.866      27210.866     -1417.5696     -1417.5696    
Loop time of 49.5959 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.742 ns/day, 13.777 hours/ns, 20.163 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.514     | 49.514     | 49.514     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014807   | 0.014807   | 0.014807   |   0.0 |  0.03
Output  | 4.8481e-05 | 4.8481e-05 | 4.8481e-05 |   0.0 |  0.00
Modify  | 0.062114   | 0.062114   | 0.062114   |   0.0 |  0.13
Other   |            | 0.005414   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223818 ave      223818 max      223818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223818
Ave neighs/atom = 111.909
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.282628117659, Press = 0.795650741456828
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    143000  -10440.443     -10440.443     -10518.998     -10518.998      304.01605      304.01605      27210.866      27210.866     -1417.5696     -1417.5696    
    144000  -10439.797     -10439.797     -10520.938     -10520.938      314.02377      314.02377      27210.504      27210.504     -1396.9099     -1396.9099    
Loop time of 49.6217 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.741 ns/day, 13.784 hours/ns, 20.152 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 49.539     | 49.539     | 49.539     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014806   | 0.014806   | 0.014806   |   0.0 |  0.03
Output  | 4.9133e-05 | 4.9133e-05 | 4.9133e-05 |   0.0 |  0.00
Modify  | 0.062029   | 0.062029   | 0.062029   |   0.0 |  0.13
Other   |            | 0.005389   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223834 ave      223834 max      223834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223834
Ave neighs/atom = 111.917
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.289133045256, Press = 0.592160461829326
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    144000  -10439.797     -10439.797     -10520.938     -10520.938      314.02377      314.02377      27210.504      27210.504     -1396.9099     -1396.9099    
    145000  -10435.177     -10435.177     -10518.901     -10518.901      324.02295      324.02295      27200.206      27200.206     -516.27986     -516.27986    
Loop time of 49.566 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.743 ns/day, 13.768 hours/ns, 20.175 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    | 49.484     | 49.484     | 49.484     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014733   | 0.014733   | 0.014733   |   0.0 |  0.03
Output  | 4.4283e-05 | 4.4283e-05 | 4.4283e-05 |   0.0 |  0.00
Modify  | 0.062069   | 0.062069   | 0.062069   |   0.0 |  0.13
Other   |            | 0.005398   |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223846 ave      223846 max      223846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223846
Ave neighs/atom = 111.923
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.301777879006, Press = 0.328597802089101
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    145000  -10435.177     -10435.177     -10518.901     -10518.901      324.02295      324.02295      27200.206      27200.206     -516.27986     -516.27986    
    146000  -10440.91      -10440.91      -10521.237     -10521.237      310.87042      310.87042      27156.057      27156.057      1647.0244      1647.0244    
Loop time of 49.5391 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.744 ns/day, 13.761 hours/ns, 20.186 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    | 49.457     | 49.457     | 49.457     |   0.0 | 99.83
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.014792   | 0.014792   | 0.014792   |   0.0 |  0.03
Output  | 4.3612e-05 | 4.3612e-05 | 4.3612e-05 |   0.0 |  0.00
Modify  | 0.06197    | 0.06197    | 0.06197    |   0.0 |  0.13
Other   |            | 0.00539    |            |       |  0.01

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       223806 ave      223806 max      223806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 223806
Ave neighs/atom = 111.903
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
27188.9068756229

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0