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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.4419521689414982*${_u_distance}
variable latticeconst_converted equal 3.4419521689414982*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.4419521689415
Lattice spacing in x,y,z = 3.4419522 3.4419522 3.4419522
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (34.419522 34.419522 34.419522)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (34.419522 34.419522 34.419522)
  create_atoms CPU = 0.005 seconds

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

kim_interactions Li

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

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


mass          1 ${mass_converted}
mass          1 6.941

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 40776.9268957422 Angstroms^3

# set the time step to 0.001 picoseconds
variable timestep_converted equal 0.001*${_u_time}
variable timestep_converted equal 0.001*1
timestep ${timestep_converted}
timestep 0.001

variable temp_converted equal 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_386038428339_000#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -3716.2389     -3716.2389     -3797.1541     -3797.1541      313.15         313.15         40776.927      40776.927      2119.5083      2119.5083    
      1000  -3631.68       -3631.68       -3714.3233     -3714.3233      319.83813      319.83813      42055.335      42055.335     -148.6026      -148.6026     
Loop time of 127.6 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.5      | 126.5      | 126.5      |   0.0 | 99.14
Neigh   | 0.50206    | 0.50206    | 0.50206    |   0.0 |  0.39
Comm    | 0.10843    | 0.10843    | 0.10843    |   0.0 |  0.08
Output  | 0.0003316  | 0.0003316  | 0.0003316  |   0.0 |  0.00
Modify  | 0.42154    | 0.42154    | 0.42154    |   0.0 |  0.33
Other   |            | 0.06369    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.04     | 123.04     | 123.04     |   0.0 | 99.04
Neigh   | 0.58819    | 0.58819    | 0.58819    |   0.0 |  0.47
Comm    | 0.10994    | 0.10994    | 0.10994    |   0.0 |  0.09
Output  | 0.00029359 | 0.00029359 | 0.00029359 |   0.0 |  0.00
Modify  | 0.42798    | 0.42798    | 0.42798    |   0.0 |  0.34
Other   |            | 0.06298    |            |       |  0.05

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

Total # of neighbors = 126922
Ave neighs/atom = 63.461
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -3634.3416     -3634.3416     -3714.7977     -3714.7977      311.37356      311.37356      42088.543      42088.543     -286.74975     -286.74975    
      3000  -3630.4867     -3630.4867     -3712.2092     -3712.2092      316.27454      316.27454      42012.632      42012.632      153.2388       153.2388     
Loop time of 111.535 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.775 ns/day, 30.982 hours/ns, 8.966 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.47     | 110.47     | 110.47     |   0.0 | 99.04
Neigh   | 0.56894    | 0.56894    | 0.56894    |   0.0 |  0.51
Comm    | 0.098274   | 0.098274   | 0.098274   |   0.0 |  0.09
Output  | 0.00020966 | 0.00020966 | 0.00020966 |   0.0 |  0.00
Modify  | 0.34282    | 0.34282    | 0.34282    |   0.0 |  0.31
Other   |            | 0.05858    |            |       |  0.05

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

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

Performance: 0.781 ns/day, 30.737 hours/ns, 9.037 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.62     | 109.62     | 109.62     |   0.0 | 99.06
Neigh   | 0.54331    | 0.54331    | 0.54331    |   0.0 |  0.49
Comm    | 0.096403   | 0.096403   | 0.096403   |   0.0 |  0.09
Output  | 0.0002578  | 0.0002578  | 0.0002578  |   0.0 |  0.00
Modify  | 0.33618    | 0.33618    | 0.33618    |   0.0 |  0.30
Other   |            | 0.05855    |            |       |  0.05

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

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

Performance: 0.782 ns/day, 30.686 hours/ns, 9.052 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.41     | 109.41     | 109.41     |   0.0 | 99.04
Neigh   | 0.56733    | 0.56733    | 0.56733    |   0.0 |  0.51
Comm    | 0.097354   | 0.097354   | 0.097354   |   0.0 |  0.09
Output  | 0.00017071 | 0.00017071 | 0.00017071 |   0.0 |  0.00
Modify  | 0.33744    | 0.33744    | 0.33744    |   0.0 |  0.31
Other   |            | 0.05809    |            |       |  0.05

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

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

Performance: 0.775 ns/day, 30.957 hours/ns, 8.973 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.38     | 110.38     | 110.38     |   0.0 | 99.05
Neigh   | 0.54731    | 0.54731    | 0.54731    |   0.0 |  0.49
Comm    | 0.097808   | 0.097808   | 0.097808   |   0.0 |  0.09
Output  | 0.00020111 | 0.00020111 | 0.00020111 |   0.0 |  0.00
Modify  | 0.36099    | 0.36099    | 0.36099    |   0.0 |  0.32
Other   |            | 0.05749    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3759 ave        3759 max        3759 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126894 ave      126894 max      126894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126894
Ave neighs/atom = 63.447
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.280070194972, Press = -63.8974885546002
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -3632.2049     -3632.2049     -3713.685      -3713.685       315.3367       315.3367       42121.502      42121.502     -258.08723     -258.08723    
      7000  -3630.4696     -3630.4696     -3711.9734     -3711.9734      315.42816      315.42816      41953.568      41953.568      246.30903      246.30903    
Loop time of 110.742 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.780 ns/day, 30.762 hours/ns, 9.030 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.68     | 109.68     | 109.68     |   0.0 | 99.04
Neigh   | 0.54719    | 0.54719    | 0.54719    |   0.0 |  0.49
Comm    | 0.097424   | 0.097424   | 0.097424   |   0.0 |  0.09
Output  | 0.00016973 | 0.00016973 | 0.00016973 |   0.0 |  0.00
Modify  | 0.35707    | 0.35707    | 0.35707    |   0.0 |  0.32
Other   |            | 0.0566     |            |       |  0.05

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

Total # of neighbors = 127576
Ave neighs/atom = 63.788
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.567754805771, Press = -27.3351432382168
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -3630.4696     -3630.4696     -3711.9734     -3711.9734      315.42816      315.42816      41953.568      41953.568      246.30903      246.30903    
      8000  -3632.024      -3632.024      -3713.8909     -3713.8909      316.83328      316.83328      41997.371      41997.371      81.80659       81.80659     
Loop time of 110.917 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.779 ns/day, 30.810 hours/ns, 9.016 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.84     | 109.84     | 109.84     |   0.0 | 99.03
Neigh   | 0.56972    | 0.56972    | 0.56972    |   0.0 |  0.51
Comm    | 0.097183   | 0.097183   | 0.097183   |   0.0 |  0.09
Output  | 0.00016968 | 0.00016968 | 0.00016968 |   0.0 |  0.00
Modify  | 0.35602    | 0.35602    | 0.35602    |   0.0 |  0.32
Other   |            | 0.05665    |            |       |  0.05

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

Total # of neighbors = 127140
Ave neighs/atom = 63.57
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.409644916163, Press = -5.2359636828644
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -3632.024      -3632.024      -3713.8909     -3713.8909      316.83328      316.83328      41997.371      41997.371      81.80659       81.80659     
      9000  -3634.6406     -3634.6406     -3714.1848     -3714.1848      307.84446      307.84446      42060.282      42060.282     -247.4094      -247.4094     
Loop time of 110.896 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.779 ns/day, 30.805 hours/ns, 9.017 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.84     | 109.84     | 109.84     |   0.0 | 99.05
Neigh   | 0.54524    | 0.54524    | 0.54524    |   0.0 |  0.49
Comm    | 0.096899   | 0.096899   | 0.096899   |   0.0 |  0.09
Output  | 0.0002048  | 0.0002048  | 0.0002048  |   0.0 |  0.00
Modify  | 0.35621    | 0.35621    | 0.35621    |   0.0 |  0.32
Other   |            | 0.05688    |            |       |  0.05

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

Total # of neighbors = 127216
Ave neighs/atom = 63.608
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.272337388421, Press = -6.28269305899362
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -3634.6406     -3634.6406     -3714.1848     -3714.1848      307.84446      307.84446      42060.282      42060.282     -247.4094      -247.4094     
     10000  -3631.5622     -3631.5622     -3713.3053     -3713.3053      316.35429      316.35429      42106.007      42106.007     -203.2413      -203.2413     
Loop time of 110.797 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.780 ns/day, 30.777 hours/ns, 9.026 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.74     | 109.74     | 109.74     |   0.0 | 99.05
Neigh   | 0.54677    | 0.54677    | 0.54677    |   0.0 |  0.49
Comm    | 0.097299   | 0.097299   | 0.097299   |   0.0 |  0.09
Output  | 0.00016952 | 0.00016952 | 0.00016952 |   0.0 |  0.00
Modify  | 0.35531    | 0.35531    | 0.35531    |   0.0 |  0.32
Other   |            | 0.05693    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3759 ave        3759 max        3759 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127102 ave      127102 max      127102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127102
Ave neighs/atom = 63.551
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.133299619958, Press = -14.4356527541131
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -3631.5622     -3631.5622     -3713.3053     -3713.3053      316.35429      316.35429      42106.007      42106.007     -203.2413      -203.2413     
     11000  -3625.0082     -3625.0082     -3710.8358     -3710.8358      332.1615       332.1615       41848.588      41848.588      839.01204      839.01204    
Loop time of 110.945 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.779 ns/day, 30.818 hours/ns, 9.013 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.86     | 109.86     | 109.86     |   0.0 | 99.03
Neigh   | 0.57069    | 0.57069    | 0.57069    |   0.0 |  0.51
Comm    | 0.0971     | 0.0971     | 0.0971     |   0.0 |  0.09
Output  | 0.00017118 | 0.00017118 | 0.00017118 |   0.0 |  0.00
Modify  | 0.35536    | 0.35536    | 0.35536    |   0.0 |  0.32
Other   |            | 0.05721    |            |       |  0.05

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

Total # of neighbors = 128170
Ave neighs/atom = 64.085
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.363641436818, Press = -3.43281976381817
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -3625.0082     -3625.0082     -3710.8358     -3710.8358      332.1615       332.1615       41848.588      41848.588      839.01204      839.01204    
     12000  -3634.0011     -3634.0011     -3715.1147     -3715.1147      313.91806      313.91806      42021.794      42021.794     -70.916603     -70.916603    
Loop time of 110.963 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.779 ns/day, 30.823 hours/ns, 9.012 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.86     | 109.86     | 109.86     |   0.0 | 99.00
Neigh   | 0.59625    | 0.59625    | 0.59625    |   0.0 |  0.54
Comm    | 0.097619   | 0.097619   | 0.097619   |   0.0 |  0.09
Output  | 0.00016895 | 0.00016895 | 0.00016895 |   0.0 |  0.00
Modify  | 0.35643    | 0.35643    | 0.35643    |   0.0 |  0.32
Other   |            | 0.05679    |            |       |  0.05

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

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

Performance: 0.736 ns/day, 32.597 hours/ns, 8.522 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.19     | 116.19     | 116.19     |   0.0 | 99.01
Neigh   | 0.59511    | 0.59511    | 0.59511    |   0.0 |  0.51
Comm    | 0.10377    | 0.10377    | 0.10377    |   0.0 |  0.09
Output  | 0.00024905 | 0.00024905 | 0.00024905 |   0.0 |  0.00
Modify  | 0.39815    | 0.39815    | 0.39815    |   0.0 |  0.34
Other   |            | 0.05989    |            |       |  0.05

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

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

Performance: 0.694 ns/day, 34.589 hours/ns, 8.031 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.31     | 123.31     | 123.31     |   0.0 | 99.03
Neigh   | 0.59146    | 0.59146    | 0.59146    |   0.0 |  0.47
Comm    | 0.1123     | 0.1123     | 0.1123     |   0.0 |  0.09
Output  | 0.00016906 | 0.00016906 | 0.00016906 |   0.0 |  0.00
Modify  | 0.44684    | 0.44684    | 0.44684    |   0.0 |  0.36
Other   |            | 0.06314    |            |       |  0.05

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

Total # of neighbors = 127282
Ave neighs/atom = 63.641
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.012493369166, Press = -7.90379473429563
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -3633.2003     -3633.2003     -3712.6647     -3712.6647      307.53571      307.53571      42006.731      42006.731      38.800806      38.800806    
     15000  -3634.7125     -3634.7125     -3712.8055     -3712.8055      302.22768      302.22768      41851.793      41851.793      378.17589      378.17589    
Loop time of 121.144 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.651 hours/ns, 8.255 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.92     | 119.92     | 119.92     |   0.0 | 98.99
Neigh   | 0.62843    | 0.62843    | 0.62843    |   0.0 |  0.52
Comm    | 0.10883    | 0.10883    | 0.10883    |   0.0 |  0.09
Output  | 0.00016952 | 0.00016952 | 0.00016952 |   0.0 |  0.00
Modify  | 0.42765    | 0.42765    | 0.42765    |   0.0 |  0.35
Other   |            | 0.0617     |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.1      | 122.1      | 122.1      |   0.0 | 99.04
Neigh   | 0.56138    | 0.56138    | 0.56138    |   0.0 |  0.46
Comm    | 0.11087    | 0.11087    | 0.11087    |   0.0 |  0.09
Output  | 0.00030416 | 0.00030416 | 0.00030416 |   0.0 |  0.00
Modify  | 0.44382    | 0.44382    | 0.44382    |   0.0 |  0.36
Other   |            | 0.06371    |            |       |  0.05

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

Total # of neighbors = 127422
Ave neighs/atom = 63.711
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.286274324619, Press = -1.86800691169377
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -3633.4692     -3633.4692     -3711.4015     -3711.4015      301.60591      301.60591      41985.447      41985.447      85.028762      85.028762    
     17000  -3636.2224     -3636.2224     -3715.8051     -3715.8051      307.99329      307.99329      41989.631      41989.631     -3.0486005     -3.0486005    
Loop time of 124.346 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.695 ns/day, 34.541 hours/ns, 8.042 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    | 123.13     | 123.13     | 123.13     |   0.0 | 99.02
Neigh   | 0.59136    | 0.59136    | 0.59136    |   0.0 |  0.48
Comm    | 0.11053    | 0.11053    | 0.11053    |   0.0 |  0.09
Output  | 0.0001662  | 0.0001662  | 0.0001662  |   0.0 |  0.00
Modify  | 0.44894    | 0.44894    | 0.44894    |   0.0 |  0.36
Other   |            | 0.06384    |            |       |  0.05

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

Total # of neighbors = 127220
Ave neighs/atom = 63.61
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.301529403195, Press = -3.43037218031217
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -3636.2224     -3636.2224     -3715.8051     -3715.8051      307.99329      307.99329      41989.631      41989.631     -3.0486005     -3.0486005    
     18000  -3632.8355     -3632.8355     -3714.3146     -3714.3146      315.33236      315.33236      42003.059      42003.059      41.484402      41.484402    
Loop time of 124.416 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.694 ns/day, 34.560 hours/ns, 8.038 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.2      | 123.2      | 123.2      |   0.0 | 99.02
Neigh   | 0.59113    | 0.59113    | 0.59113    |   0.0 |  0.48
Comm    | 0.11124    | 0.11124    | 0.11124    |   0.0 |  0.09
Output  | 0.0002036  | 0.0002036  | 0.0002036  |   0.0 |  0.00
Modify  | 0.44983    | 0.44983    | 0.44983    |   0.0 |  0.36
Other   |            | 0.06413    |            |       |  0.05

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

Total # of neighbors = 127530
Ave neighs/atom = 63.765
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.061959466586, Press = -1.58730854013001
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -3632.8355     -3632.8355     -3714.3146     -3714.3146      315.33236      315.33236      42003.059      42003.059      41.484402      41.484402    
     19000  -3636.2266     -3636.2266     -3714.5846     -3714.5846      303.25347      303.25347      42005.301      42005.301     -40.716322     -40.716322    
Loop time of 124.427 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.694 ns/day, 34.563 hours/ns, 8.037 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    | 123.19     | 123.19     | 123.19     |   0.0 | 99.00
Neigh   | 0.6183     | 0.6183     | 0.6183     |   0.0 |  0.50
Comm    | 0.1106     | 0.1106     | 0.1106     |   0.0 |  0.09
Output  | 0.00017059 | 0.00017059 | 0.00017059 |   0.0 |  0.00
Modify  | 0.44958    | 0.44958    | 0.44958    |   0.0 |  0.36
Other   |            | 0.06361    |            |       |  0.05

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

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

Performance: 0.695 ns/day, 34.545 hours/ns, 8.041 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    | 123.14     | 123.14     | 123.14     |   0.0 | 99.02
Neigh   | 0.59546    | 0.59546    | 0.59546    |   0.0 |  0.48
Comm    | 0.11146    | 0.11146    | 0.11146    |   0.0 |  0.09
Output  | 0.00020556 | 0.00020556 | 0.00020556 |   0.0 |  0.00
Modify  | 0.44927    | 0.44927    | 0.44927    |   0.0 |  0.36
Other   |            | 0.06422    |            |       |  0.05

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

Total # of neighbors = 127688
Ave neighs/atom = 63.844
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.960066239191, Press = -2.80496211624439
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -3630.7232     -3630.7232     -3711.8419     -3711.8419      313.93799      313.93799      42014.33       42014.33       48.73376       48.73376     
     21000  -3634.57       -3634.57       -3715.0486     -3715.0486      311.46043      311.46043      42038.836      42038.836     -69.453173     -69.453173    
Loop time of 124.382 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.695 ns/day, 34.550 hours/ns, 8.040 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    | 123.14     | 123.14     | 123.14     |   0.0 | 99.00
Neigh   | 0.61593    | 0.61593    | 0.61593    |   0.0 |  0.50
Comm    | 0.11144    | 0.11144    | 0.11144    |   0.0 |  0.09
Output  | 0.00016971 | 0.00016971 | 0.00016971 |   0.0 |  0.00
Modify  | 0.44947    | 0.44947    | 0.44947    |   0.0 |  0.36
Other   |            | 0.06315    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3759 ave        3759 max        3759 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127206 ave      127206 max      127206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.697 ns/day, 34.444 hours/ns, 8.065 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.78     | 122.78     | 122.78     |   0.0 | 99.02
Neigh   | 0.59273    | 0.59273    | 0.59273    |   0.0 |  0.48
Comm    | 0.11012    | 0.11012    | 0.11012    |   0.0 |  0.09
Output  | 0.00017167 | 0.00017167 | 0.00017167 |   0.0 |  0.00
Modify  | 0.44897    | 0.44897    | 0.44897    |   0.0 |  0.36
Other   |            | 0.06402    |            |       |  0.05

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

Total # of neighbors = 127400
Ave neighs/atom = 63.7
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.158132162312, Press = -3.05747676720465
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -3629.1351     -3629.1351     -3710.4242     -3710.4242      314.59725      314.59725      42063.459      42063.459      115.19187      115.19187    
     23000  -3633.3875     -3633.3875     -3715.7132     -3715.7132      318.60906      318.60906      41968.604      41968.604      119.26169      119.26169    
Loop time of 123.993 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.697 ns/day, 34.443 hours/ns, 8.065 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.78     | 122.78     | 122.78     |   0.0 | 99.02
Neigh   | 0.59241    | 0.59241    | 0.59241    |   0.0 |  0.48
Comm    | 0.1098     | 0.1098     | 0.1098     |   0.0 |  0.09
Output  | 0.00020474 | 0.00020474 | 0.00020474 |   0.0 |  0.00
Modify  | 0.44524    | 0.44524    | 0.44524    |   0.0 |  0.36
Other   |            | 0.06335    |            |       |  0.05

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

Total # of neighbors = 127314
Ave neighs/atom = 63.657
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.292215461919, Press = -2.23463530053681
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -3633.3875     -3633.3875     -3715.7132     -3715.7132      318.60906      318.60906      41968.604      41968.604      119.26169      119.26169    
     24000  -3629.4815     -3629.4815     -3712.8765     -3712.8765      322.74724      322.74724      42151.962      42151.962     -292.42507     -292.42507    
Loop time of 112.036 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.771 ns/day, 31.121 hours/ns, 8.926 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.93     | 110.93     | 110.93     |   0.0 | 99.02
Neigh   | 0.57778    | 0.57778    | 0.57778    |   0.0 |  0.52
Comm    | 0.10034    | 0.10034    | 0.10034    |   0.0 |  0.09
Output  | 0.00020384 | 0.00020384 | 0.00020384 |   0.0 |  0.00
Modify  | 0.36644    | 0.36644    | 0.36644    |   0.0 |  0.33
Other   |            | 0.05694    |            |       |  0.05

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

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

Performance: 0.782 ns/day, 30.679 hours/ns, 9.054 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.36     | 109.36     | 109.36     |   0.0 | 99.02
Neigh   | 0.5694     | 0.5694     | 0.5694     |   0.0 |  0.52
Comm    | 0.098423   | 0.098423   | 0.098423   |   0.0 |  0.09
Output  | 0.00016754 | 0.00016754 | 0.00016754 |   0.0 |  0.00
Modify  | 0.358      | 0.358      | 0.358      |   0.0 |  0.32
Other   |            | 0.05696    |            |       |  0.05

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

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

Performance: 0.780 ns/day, 30.787 hours/ns, 9.023 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.78     | 109.78     | 109.78     |   0.0 | 99.05
Neigh   | 0.54396    | 0.54396    | 0.54396    |   0.0 |  0.49
Comm    | 0.097684   | 0.097684   | 0.097684   |   0.0 |  0.09
Output  | 0.00017278 | 0.00017278 | 0.00017278 |   0.0 |  0.00
Modify  | 0.35788    | 0.35788    | 0.35788    |   0.0 |  0.32
Other   |            | 0.05728    |            |       |  0.05

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

Total # of neighbors = 127314
Ave neighs/atom = 63.657
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.488146469155, Press = -1.77958050673344
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -3633.5854     -3633.5854     -3714.0388     -3714.0388      311.36311      311.36311      41958.948      41958.948      193.46939      193.46939    
     27000  -3634.2166     -3634.2166     -3714.868      -3714.868       312.12917      312.12917      42058.634      42058.634     -80.199208     -80.199208    
Loop time of 119.561 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.37     | 118.37     | 118.37     |   0.0 | 99.00
Neigh   | 0.60326    | 0.60326    | 0.60326    |   0.0 |  0.50
Comm    | 0.10678    | 0.10678    | 0.10678    |   0.0 |  0.09
Output  | 0.0002063  | 0.0002063  | 0.0002063  |   0.0 |  0.00
Modify  | 0.42101    | 0.42101    | 0.42101    |   0.0 |  0.35
Other   |            | 0.06163    |            |       |  0.05

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

Total # of neighbors = 127034
Ave neighs/atom = 63.517
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.508004219545, Press = -1.67736262622973
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -3634.2166     -3634.2166     -3714.868      -3714.868       312.12917      312.12917      42058.634      42058.634     -80.199208     -80.199208    
     28000  -3631.8403     -3631.8403     -3715.2056     -3715.2056      322.6324       322.6324       42004.313      42004.313      117.46952      117.46952    
Loop time of 124.038 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.697 ns/day, 34.455 hours/ns, 8.062 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.83     | 122.83     | 122.83     |   0.0 | 99.02
Neigh   | 0.58895    | 0.58895    | 0.58895    |   0.0 |  0.47
Comm    | 0.10962    | 0.10962    | 0.10962    |   0.0 |  0.09
Output  | 0.00020707 | 0.00020707 | 0.00020707 |   0.0 |  0.00
Modify  | 0.45052    | 0.45052    | 0.45052    |   0.0 |  0.36
Other   |            | 0.06327    |            |       |  0.05

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

Total # of neighbors = 127102
Ave neighs/atom = 63.551
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.484019748928, Press = -2.77095287583415
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -3631.8403     -3631.8403     -3715.2056     -3715.2056      322.6324       322.6324       42004.313      42004.313      117.46952      117.46952    
     29000  -3633.2743     -3633.2743     -3714.2209     -3714.2209      313.27177      313.27177      41914.675      41914.675      376.21164      376.21164    
Loop time of 111.638 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.774 ns/day, 31.011 hours/ns, 8.957 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.55     | 110.55     | 110.55     |   0.0 | 99.03
Neigh   | 0.56985    | 0.56985    | 0.56985    |   0.0 |  0.51
Comm    | 0.098449   | 0.098449   | 0.098449   |   0.0 |  0.09
Output  | 0.00016918 | 0.00016918 | 0.00016918 |   0.0 |  0.00
Modify  | 0.35931    | 0.35931    | 0.35931    |   0.0 |  0.32
Other   |            | 0.05797    |            |       |  0.05

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

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

Performance: 0.713 ns/day, 33.676 hours/ns, 8.248 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.03     | 120.03     | 120.03     |   0.0 | 99.01
Neigh   | 0.60299    | 0.60299    | 0.60299    |   0.0 |  0.50
Comm    | 0.1087     | 0.1087     | 0.1087     |   0.0 |  0.09
Output  | 0.00020429 | 0.00020429 | 0.00020429 |   0.0 |  0.00
Modify  | 0.4277     | 0.4277     | 0.4277     |   0.0 |  0.35
Other   |            | 0.06192    |            |       |  0.05

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

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

Performance: 0.696 ns/day, 34.459 hours/ns, 8.061 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.81     | 122.81     | 122.81     |   0.0 | 99.00
Neigh   | 0.61589    | 0.61589    | 0.61589    |   0.0 |  0.50
Comm    | 0.11152    | 0.11152    | 0.11152    |   0.0 |  0.09
Output  | 0.00020403 | 0.00020403 | 0.00020403 |   0.0 |  0.00
Modify  | 0.44944    | 0.44944    | 0.44944    |   0.0 |  0.36
Other   |            | 0.06357    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3745 ave        3745 max        3745 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127174 ave      127174 max      127174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.698 ns/day, 34.398 hours/ns, 8.075 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.6      | 122.6      | 122.6      |   0.0 | 99.00
Neigh   | 0.61411    | 0.61411    | 0.61411    |   0.0 |  0.50
Comm    | 0.11136    | 0.11136    | 0.11136    |   0.0 |  0.09
Output  | 0.00016973 | 0.00016973 | 0.00016973 |   0.0 |  0.00
Modify  | 0.44591    | 0.44591    | 0.44591    |   0.0 |  0.36
Other   |            | 0.06341    |            |       |  0.05

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

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

Performance: 0.697 ns/day, 34.454 hours/ns, 8.062 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.8      | 122.8      | 122.8      |   0.0 | 99.01
Neigh   | 0.61154    | 0.61154    | 0.61154    |   0.0 |  0.49
Comm    | 0.10996    | 0.10996    | 0.10996    |   0.0 |  0.09
Output  | 0.00020148 | 0.00020148 | 0.00020148 |   0.0 |  0.00
Modify  | 0.44428    | 0.44428    | 0.44428    |   0.0 |  0.36
Other   |            | 0.06236    |            |       |  0.05

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

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

Performance: 0.695 ns/day, 34.539 hours/ns, 8.042 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.11     | 123.11     | 123.11     |   0.0 | 99.01
Neigh   | 0.61066    | 0.61066    | 0.61066    |   0.0 |  0.49
Comm    | 0.11078    | 0.11078    | 0.11078    |   0.0 |  0.09
Output  | 0.00020847 | 0.00020847 | 0.00020847 |   0.0 |  0.00
Modify  | 0.44878    | 0.44878    | 0.44878    |   0.0 |  0.36
Other   |            | 0.06286    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3836 ave        3836 max        3836 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127544 ave      127544 max      127544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.758 ns/day, 31.656 hours/ns, 8.775 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.85     | 112.85     | 112.85     |   0.0 | 99.02
Neigh   | 0.5786     | 0.5786     | 0.5786     |   0.0 |  0.51
Comm    | 0.1006     | 0.1006     | 0.1006     |   0.0 |  0.09
Output  | 0.00017145 | 0.00017145 | 0.00017145 |   0.0 |  0.00
Modify  | 0.37874    | 0.37874    | 0.37874    |   0.0 |  0.33
Other   |            | 0.05877    |            |       |  0.05

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

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

Performance: 0.779 ns/day, 30.824 hours/ns, 9.012 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.88     | 109.88     | 109.88     |   0.0 | 99.02
Neigh   | 0.56993    | 0.56993    | 0.56993    |   0.0 |  0.51
Comm    | 0.098483   | 0.098483   | 0.098483   |   0.0 |  0.09
Output  | 0.00016973 | 0.00016973 | 0.00016973 |   0.0 |  0.00
Modify  | 0.35735    | 0.35735    | 0.35735    |   0.0 |  0.32
Other   |            | 0.05687    |            |       |  0.05

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

Total # of neighbors = 127046
Ave neighs/atom = 63.523
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.485633888628, Press = -1.95200640346052
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -3631.6581     -3631.6581     -3711.204      -3711.204       307.8506       307.8506       42067.99       42067.99      -27.03492      -27.03492     
     37000  -3631.8967     -3631.8967     -3713.0131     -3713.0131      313.92885      313.92885      41978.989      41978.989      126.03155      126.03155    
Loop time of 111.052 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110        | 110        | 110        |   0.0 | 99.05
Neigh   | 0.544      | 0.544      | 0.544      |   0.0 |  0.49
Comm    | 0.097501   | 0.097501   | 0.097501   |   0.0 |  0.09
Output  | 0.00016947 | 0.00016947 | 0.00016947 |   0.0 |  0.00
Modify  | 0.35726    | 0.35726    | 0.35726    |   0.0 |  0.32
Other   |            | 0.05691    |            |       |  0.05

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

Total # of neighbors = 127490
Ave neighs/atom = 63.745
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.487726770863, Press = -0.729565038823579
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -3631.8967     -3631.8967     -3713.0131     -3713.0131      313.92885      313.92885      41978.989      41978.989      126.03155      126.03155    
     38000  -3633.8293     -3633.8293     -3714.0506     -3714.0506      310.46477      310.46477      42213.701      42213.701     -730.71312     -730.71312    
Loop time of 110.898 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.779 ns/day, 30.805 hours/ns, 9.017 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.82     | 109.82     | 109.82     |   0.0 | 99.02
Neigh   | 0.56926    | 0.56926    | 0.56926    |   0.0 |  0.51
Comm    | 0.098312   | 0.098312   | 0.098312   |   0.0 |  0.09
Output  | 0.00048587 | 0.00048587 | 0.00048587 |   0.0 |  0.00
Modify  | 0.35729    | 0.35729    | 0.35729    |   0.0 |  0.32
Other   |            | 0.05712    |            |       |  0.05

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

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

Performance: 0.781 ns/day, 30.730 hours/ns, 9.039 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.57     | 109.57     | 109.57     |   0.0 | 99.05
Neigh   | 0.54416    | 0.54416    | 0.54416    |   0.0 |  0.49
Comm    | 0.097451   | 0.097451   | 0.097451   |   0.0 |  0.09
Output  | 0.0001704  | 0.0001704  | 0.0001704  |   0.0 |  0.00
Modify  | 0.35741    | 0.35741    | 0.35741    |   0.0 |  0.32
Other   |            | 0.05675    |            |       |  0.05

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

Total # of neighbors = 127138
Ave neighs/atom = 63.569
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.482254264124, Press = -3.75280494649823
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -3631.8998     -3631.8998     -3714.0723     -3714.0723      318.01631      318.01631      42089.547      42089.547     -274.70549     -274.70549    
     40000  -3634.7982     -3634.7982     -3714.046      -3714.046       306.69721      306.69721      41833.946      41833.946      496.38526      496.38526    
Loop time of 111.09 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.01     | 110.01     | 110.01     |   0.0 | 99.03
Neigh   | 0.5705     | 0.5705     | 0.5705     |   0.0 |  0.51
Comm    | 0.098161   | 0.098161   | 0.098161   |   0.0 |  0.09
Output  | 0.00021391 | 0.00021391 | 0.00021391 |   0.0 |  0.00
Modify  | 0.35663    | 0.35663    | 0.35663    |   0.0 |  0.32
Other   |            | 0.05691    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3846 ave        3846 max        3846 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127668 ave      127668 max      127668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127668
Ave neighs/atom = 63.834
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.39061660287, Press = -1.50931270866204
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -3634.7982     -3634.7982     -3714.046      -3714.046       306.69721      306.69721      41833.946      41833.946      496.38526      496.38526    
     41000  -3633.0481     -3633.0481     -3715.1846     -3715.1846      317.87708      317.87708      41982.188      41982.188      127.23951      127.23951    
Loop time of 111.066 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.98     | 109.98     | 109.98     |   0.0 | 99.02
Neigh   | 0.56893    | 0.56893    | 0.56893    |   0.0 |  0.51
Comm    | 0.098598   | 0.098598   | 0.098598   |   0.0 |  0.09
Output  | 0.00017099 | 0.00017099 | 0.00017099 |   0.0 |  0.00
Modify  | 0.35853    | 0.35853    | 0.35853    |   0.0 |  0.32
Other   |            | 0.05683    |            |       |  0.05

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

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

Performance: 0.779 ns/day, 30.801 hours/ns, 9.018 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.83     | 109.83     | 109.83     |   0.0 | 99.05
Neigh   | 0.54563    | 0.54563    | 0.54563    |   0.0 |  0.49
Comm    | 0.097432   | 0.097432   | 0.097432   |   0.0 |  0.09
Output  | 0.00021182 | 0.00021182 | 0.00021182 |   0.0 |  0.00
Modify  | 0.35759    | 0.35759    | 0.35759    |   0.0 |  0.32
Other   |            | 0.05734    |            |       |  0.05

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

Total # of neighbors = 127418
Ave neighs/atom = 63.709
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.305965736373, Press = -0.413243050564855
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -3632.7216     -3632.7216     -3712.9875     -3712.9875      310.63745      310.63745      42036.967      42036.967     -113.84748     -113.84748    
     43000  -3630.2358     -3630.2358     -3712.4234     -3712.4234      318.07425      318.07425      42194.158      42194.158     -431.99942     -431.99942    
Loop time of 110.729 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.780 ns/day, 30.758 hours/ns, 9.031 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.65     | 109.65     | 109.65     |   0.0 | 99.02
Neigh   | 0.56905    | 0.56905    | 0.56905    |   0.0 |  0.51
Comm    | 0.099012   | 0.099012   | 0.099012   |   0.0 |  0.09
Output  | 0.00016948 | 0.00016948 | 0.00016948 |   0.0 |  0.00
Modify  | 0.35648    | 0.35648    | 0.35648    |   0.0 |  0.32
Other   |            | 0.0567     |            |       |  0.05

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

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

Performance: 0.780 ns/day, 30.764 hours/ns, 9.029 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.64     | 109.64     | 109.64     |   0.0 | 99.00
Neigh   | 0.59474    | 0.59474    | 0.59474    |   0.0 |  0.54
Comm    | 0.098611   | 0.098611   | 0.098611   |   0.0 |  0.09
Output  | 0.00017092 | 0.00017092 | 0.00017092 |   0.0 |  0.00
Modify  | 0.35758    | 0.35758    | 0.35758    |   0.0 |  0.32
Other   |            | 0.05662    |            |       |  0.05

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

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

Performance: 0.779 ns/day, 30.822 hours/ns, 9.012 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.88     | 109.88     | 109.88     |   0.0 | 99.02
Neigh   | 0.56982    | 0.56982    | 0.56982    |   0.0 |  0.51
Comm    | 0.098261   | 0.098261   | 0.098261   |   0.0 |  0.09
Output  | 0.00017131 | 0.00017131 | 0.00017131 |   0.0 |  0.00
Modify  | 0.35786    | 0.35786    | 0.35786    |   0.0 |  0.32
Other   |            | 0.05698    |            |       |  0.05

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

Total # of neighbors = 127660
Ave neighs/atom = 63.83
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.32895587294, Press = -1.15904904433013
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -3630.8069     -3630.8069     -3714.3891     -3714.3891      323.47161      323.47161      41867.738      41867.738      526.96622      526.96622    
     46000  -3633.2221     -3633.2221     -3713.8048     -3713.8048      311.86346      311.86346      42080.435      42080.435     -64.457909     -64.457909    
Loop time of 110.877 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.779 ns/day, 30.799 hours/ns, 9.019 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.82     | 109.82     | 109.82     |   0.0 | 99.05
Neigh   | 0.54346    | 0.54346    | 0.54346    |   0.0 |  0.49
Comm    | 0.098414   | 0.098414   | 0.098414   |   0.0 |  0.09
Output  | 0.00017084 | 0.00017084 | 0.00017084 |   0.0 |  0.00
Modify  | 0.35682    | 0.35682    | 0.35682    |   0.0 |  0.32
Other   |            | 0.05708    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3704 ave        3704 max        3704 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127092 ave      127092 max      127092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127092
Ave neighs/atom = 63.546
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.358709574631, Press = 0.0851213019168024
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -3633.2221     -3633.2221     -3713.8048     -3713.8048      311.86346      311.86346      42080.435      42080.435     -64.457909     -64.457909    
     47000  -3632.4582     -3632.4582     -3713.409      -3713.409       313.28793      313.28793      42099.654      42099.654     -221.50505     -221.50505    
Loop time of 117.966 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.79     | 116.79     | 116.79     |   0.0 | 99.00
Neigh   | 0.59662    | 0.59662    | 0.59662    |   0.0 |  0.51
Comm    | 0.10674    | 0.10674    | 0.10674    |   0.0 |  0.09
Output  | 0.00016825 | 0.00016825 | 0.00016825 |   0.0 |  0.00
Modify  | 0.40952    | 0.40952    | 0.40952    |   0.0 |  0.35
Other   |            | 0.0609     |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.49     | 119.49     | 119.49     |   0.0 | 99.00
Neigh   | 0.6032     | 0.6032     | 0.6032     |   0.0 |  0.50
Comm    | 0.10947    | 0.10947    | 0.10947    |   0.0 |  0.09
Output  | 0.00016822 | 0.00016822 | 0.00016822 |   0.0 |  0.00
Modify  | 0.42898    | 0.42898    | 0.42898    |   0.0 |  0.36
Other   |            | 0.06221    |            |       |  0.05

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

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

Performance: 0.696 ns/day, 34.507 hours/ns, 8.050 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.99     | 122.99     | 122.99     |   0.0 | 99.00
Neigh   | 0.61916    | 0.61916    | 0.61916    |   0.0 |  0.50
Comm    | 0.11052    | 0.11052    | 0.11052    |   0.0 |  0.09
Output  | 0.00029409 | 0.00029409 | 0.00029409 |   0.0 |  0.00
Modify  | 0.446      | 0.446      | 0.446      |   0.0 |  0.36
Other   |            | 0.06285    |            |       |  0.05

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

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

Performance: 0.696 ns/day, 34.493 hours/ns, 8.053 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.93     | 122.93     | 122.93     |   0.0 | 99.00
Neigh   | 0.61594    | 0.61594    | 0.61594    |   0.0 |  0.50
Comm    | 0.11024    | 0.11024    | 0.11024    |   0.0 |  0.09
Output  | 0.00016828 | 0.00016828 | 0.00016828 |   0.0 |  0.00
Modify  | 0.45306    | 0.45306    | 0.45306    |   0.0 |  0.36
Other   |            | 0.06225    |            |       |  0.05

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

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

Performance: 0.717 ns/day, 33.488 hours/ns, 8.295 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.36     | 119.36     | 119.36     |   0.0 | 99.01
Neigh   | 0.60128    | 0.60128    | 0.60128    |   0.0 |  0.50
Comm    | 0.1076     | 0.1076     | 0.1076     |   0.0 |  0.09
Output  | 0.00016723 | 0.00016723 | 0.00016723 |   0.0 |  0.00
Modify  | 0.42713    | 0.42713    | 0.42713    |   0.0 |  0.35
Other   |            | 0.06041    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.18     | 109.18     | 109.18     |   0.0 | 99.03
Neigh   | 0.56627    | 0.56627    | 0.56627    |   0.0 |  0.51
Comm    | 0.096619   | 0.096619   | 0.096619   |   0.0 |  0.09
Output  | 0.00016828 | 0.00016828 | 0.00016828 |   0.0 |  0.00
Modify  | 0.3543     | 0.3543     | 0.3543     |   0.0 |  0.32
Other   |            | 0.05615    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3822 ave        3822 max        3822 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127566 ave      127566 max      127566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.729 ns/day, 32.933 hours/ns, 8.435 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.38     | 117.38     | 117.38     |   0.0 | 99.01
Neigh   | 0.59708    | 0.59708    | 0.59708    |   0.0 |  0.50
Comm    | 0.10527    | 0.10527    | 0.10527    |   0.0 |  0.09
Output  | 0.00020902 | 0.00020902 | 0.00020902 |   0.0 |  0.00
Modify  | 0.41429    | 0.41429    | 0.41429    |   0.0 |  0.35
Other   |            | 0.05984    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.52     | 122.52     | 122.52     |   0.0 | 99.00
Neigh   | 0.61497    | 0.61497    | 0.61497    |   0.0 |  0.50
Comm    | 0.11142    | 0.11142    | 0.11142    |   0.0 |  0.09
Output  | 0.00020433 | 0.00020433 | 0.00020433 |   0.0 |  0.00
Modify  | 0.45187    | 0.45187    | 0.45187    |   0.0 |  0.37
Other   |            | 0.06243    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3842 ave        3842 max        3842 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127064 ave      127064 max      127064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127064
Ave neighs/atom = 63.532
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.469344202635, Press = -1.66858129891457
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -3634.175      -3634.175      -3714.1684     -3714.1684      309.58264      309.58264      42027.794      42027.794     -77.970349     -77.970349    
     55000  -3630.3056     -3630.3056     -3712.0428     -3712.0428      316.33149      316.33149      41992.309      41992.309      217.01822      217.01822    
Loop time of 124.241 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.695 ns/day, 34.511 hours/ns, 8.049 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.03     | 123.03     | 123.03     |   0.0 | 99.03
Neigh   | 0.58693    | 0.58693    | 0.58693    |   0.0 |  0.47
Comm    | 0.11111    | 0.11111    | 0.11111    |   0.0 |  0.09
Output  | 0.00025137 | 0.00025137 | 0.00025137 |   0.0 |  0.00
Modify  | 0.44913    | 0.44913    | 0.44913    |   0.0 |  0.36
Other   |            | 0.0622     |            |       |  0.05

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

Total # of neighbors = 127516
Ave neighs/atom = 63.758
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.460709578772, Press = -0.757699129132006
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -3630.3056     -3630.3056     -3712.0428     -3712.0428      316.33149      316.33149      41992.309      41992.309      217.01822      217.01822    
     56000  -3631.5723     -3631.5723     -3712.9714     -3712.9714      315.02307      315.02307      42071.309      42071.309     -39.847786     -39.847786    
Loop time of 123.925 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.697 ns/day, 34.424 hours/ns, 8.069 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.69     | 122.69     | 122.69     |   0.0 | 99.00
Neigh   | 0.61229    | 0.61229    | 0.61229    |   0.0 |  0.49
Comm    | 0.11019    | 0.11019    | 0.11019    |   0.0 |  0.09
Output  | 0.00017996 | 0.00017996 | 0.00017996 |   0.0 |  0.00
Modify  | 0.44872    | 0.44872    | 0.44872    |   0.0 |  0.36
Other   |            | 0.06176    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3846 ave        3846 max        3846 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127260 ave      127260 max      127260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127260
Ave neighs/atom = 63.63
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.505780603993, Press = -0.938167971528296
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -3631.5723     -3631.5723     -3712.9714     -3712.9714      315.02307      315.02307      42071.309      42071.309     -39.847786     -39.847786    
     57000  -3635.9837     -3635.9837     -3715.3031     -3715.3031      306.9743       306.9743       41919.986      41919.986      269.74928      269.74928    
Loop time of 124.418 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.694 ns/day, 34.561 hours/ns, 8.037 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.15     | 123.15     | 123.15     |   0.0 | 98.98
Neigh   | 0.63829    | 0.63829    | 0.63829    |   0.0 |  0.51
Comm    | 0.11174    | 0.11174    | 0.11174    |   0.0 |  0.09
Output  | 0.00016769 | 0.00016769 | 0.00016769 |   0.0 |  0.00
Modify  | 0.45306    | 0.45306    | 0.45306    |   0.0 |  0.36
Other   |            | 0.06309    |            |       |  0.05

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

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

Performance: 0.698 ns/day, 34.369 hours/ns, 8.082 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.5      | 122.5      | 122.5      |   0.0 | 99.01
Neigh   | 0.61306    | 0.61306    | 0.61306    |   0.0 |  0.50
Comm    | 0.11021    | 0.11021    | 0.11021    |   0.0 |  0.09
Output  | 0.00020515 | 0.00020515 | 0.00020515 |   0.0 |  0.00
Modify  | 0.44076    | 0.44076    | 0.44076    |   0.0 |  0.36
Other   |            | 0.06212    |            |       |  0.05

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

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

Performance: 0.689 ns/day, 34.815 hours/ns, 7.979 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.07     | 124.07     | 124.07     |   0.0 | 98.99
Neigh   | 0.62514    | 0.62514    | 0.62514    |   0.0 |  0.50
Comm    | 0.11491    | 0.11491    | 0.11491    |   0.0 |  0.09
Output  | 0.00025233 | 0.00025233 | 0.00025233 |   0.0 |  0.00
Modify  | 0.46205    | 0.46205    | 0.46205    |   0.0 |  0.37
Other   |            | 0.06264    |            |       |  0.05

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

Total # of neighbors = 126932
Ave neighs/atom = 63.466
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.45908507952, Press = -1.73933952058539
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -3632.9341     -3632.9341     -3714.6402     -3714.6402      316.21119      316.21119      42121.944      42121.944     -345.87015     -345.87015    
     60000  -3632.3647     -3632.3647     -3714.8966     -3714.8966      319.40675      319.40675      41843.455      41843.455      595.48293      595.48293    
Loop time of 123.582 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.36     | 122.36     | 122.36     |   0.0 | 99.01
Neigh   | 0.60888    | 0.60888    | 0.60888    |   0.0 |  0.49
Comm    | 0.11105    | 0.11105    | 0.11105    |   0.0 |  0.09
Output  | 0.00016908 | 0.00016908 | 0.00016908 |   0.0 |  0.00
Modify  | 0.44392    | 0.44392    | 0.44392    |   0.0 |  0.36
Other   |            | 0.06107    |            |       |  0.05

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

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

Performance: 0.747 ns/day, 32.109 hours/ns, 8.651 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.49     | 114.49     | 114.49     |   0.0 | 99.04
Neigh   | 0.55767    | 0.55767    | 0.55767    |   0.0 |  0.48
Comm    | 0.10115    | 0.10115    | 0.10115    |   0.0 |  0.09
Output  | 0.00016927 | 0.00016927 | 0.00016927 |   0.0 |  0.00
Modify  | 0.38838    | 0.38838    | 0.38838    |   0.0 |  0.34
Other   |            | 0.05868    |            |       |  0.05

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

Total # of neighbors = 127418
Ave neighs/atom = 63.709
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.421855953401, Press = -0.10877918722511
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -3631.5568     -3631.5568     -3711.5005     -3711.5005      309.39053      309.39053      42058.11       42058.11      -40.750865     -40.750865    
     62000  -3631.7141     -3631.7141     -3713.7146     -3713.7146      317.35022      317.35022      42054.197      42054.197     -123.05025     -123.05025    
Loop time of 111.006 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.778 ns/day, 30.835 hours/ns, 9.009 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.92     | 109.92     | 109.92     |   0.0 | 99.02
Neigh   | 0.57124    | 0.57124    | 0.57124    |   0.0 |  0.51
Comm    | 0.097062   | 0.097062   | 0.097062   |   0.0 |  0.09
Output  | 0.00016931 | 0.00016931 | 0.00016931 |   0.0 |  0.00
Modify  | 0.35708    | 0.35708    | 0.35708    |   0.0 |  0.32
Other   |            | 0.05728    |            |       |  0.05

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

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

Performance: 0.780 ns/day, 30.788 hours/ns, 9.022 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.75     | 109.75     | 109.75     |   0.0 | 99.02
Neigh   | 0.57136    | 0.57136    | 0.57136    |   0.0 |  0.52
Comm    | 0.09686    | 0.09686    | 0.09686    |   0.0 |  0.09
Output  | 0.00020785 | 0.00020785 | 0.00020785 |   0.0 |  0.00
Modify  | 0.35833    | 0.35833    | 0.35833    |   0.0 |  0.32
Other   |            | 0.05761    |            |       |  0.05

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

Total # of neighbors = 127100
Ave neighs/atom = 63.55
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.404004495083, Press = -0.804688713883251
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -3630.228      -3630.228      -3712.9985     -3712.9985      320.33046      320.33046      42178.745      42178.745     -400.89709     -400.89709    
     64000  -3632.4321     -3632.4321     -3714.4913     -3714.4913      317.5778       317.5778       41943.886      41943.886      259.94966      259.94966    
Loop time of 110.89 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.779 ns/day, 30.803 hours/ns, 9.018 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.8      | 109.8      | 109.8      |   0.0 | 99.02
Neigh   | 0.56953    | 0.56953    | 0.56953    |   0.0 |  0.51
Comm    | 0.097465   | 0.097465   | 0.097465   |   0.0 |  0.09
Output  | 0.00021341 | 0.00021341 | 0.00021341 |   0.0 |  0.00
Modify  | 0.36031    | 0.36031    | 0.36031    |   0.0 |  0.32
Other   |            | 0.05754    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3729 ave        3729 max        3729 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127606 ave      127606 max      127606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.725 ns/day, 33.114 hours/ns, 8.388 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.06     | 118.06     | 118.06     |   0.0 | 99.03
Neigh   | 0.57049    | 0.57049    | 0.57049    |   0.0 |  0.48
Comm    | 0.10545    | 0.10545    | 0.10545    |   0.0 |  0.09
Output  | 0.00020552 | 0.00020552 | 0.00020552 |   0.0 |  0.00
Modify  | 0.41573    | 0.41573    | 0.41573    |   0.0 |  0.35
Other   |            | 0.05944    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3823 ave        3823 max        3823 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128028 ave      128028 max      128028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128028
Ave neighs/atom = 64.014
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.391150016762, Press = -0.558330689608322
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -3637.9439     -3637.9439     -3715.9317     -3715.9317      301.82077      301.82077      41758.013      41758.013      644.22903      644.22903    
     66000  -3632.3882     -3632.3882     -3712.9364     -3712.9364      311.72992      311.72992      42049.398      42049.398     -105.67394     -105.67394    
Loop time of 119.418 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.172 hours/ns, 8.374 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.26     | 118.26     | 118.26     |   0.0 | 99.03
Neigh   | 0.57145    | 0.57145    | 0.57145    |   0.0 |  0.48
Comm    | 0.10586    | 0.10586    | 0.10586    |   0.0 |  0.09
Output  | 0.0001705  | 0.0001705  | 0.0001705  |   0.0 |  0.00
Modify  | 0.41513    | 0.41513    | 0.41513    |   0.0 |  0.35
Other   |            | 0.06085    |            |       |  0.05

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

Total # of neighbors = 127510
Ave neighs/atom = 63.755
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.358535632257, Press = -0.0838276490141959
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -3632.3882     -3632.3882     -3712.9364     -3712.9364      311.72992      311.72992      42049.398      42049.398     -105.67394     -105.67394    
     67000  -3628.4999     -3628.4999     -3710.6817     -3710.6817      318.05199      318.05199      42172.197      42172.197     -354.56496     -354.56496    
Loop time of 123.701 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.698 ns/day, 34.361 hours/ns, 8.084 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.47     | 122.47     | 122.47     |   0.0 | 99.00
Neigh   | 0.61351    | 0.61351    | 0.61351    |   0.0 |  0.50
Comm    | 0.10996    | 0.10996    | 0.10996    |   0.0 |  0.09
Output  | 0.00016869 | 0.00016869 | 0.00016869 |   0.0 |  0.00
Modify  | 0.44682    | 0.44682    | 0.44682    |   0.0 |  0.36
Other   |            | 0.06098    |            |       |  0.05

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

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

Performance: 0.697 ns/day, 34.449 hours/ns, 8.063 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.8      | 122.8      | 122.8      |   0.0 | 99.02
Neigh   | 0.58682    | 0.58682    | 0.58682    |   0.0 |  0.47
Comm    | 0.11037    | 0.11037    | 0.11037    |   0.0 |  0.09
Output  | 0.00022251 | 0.00022251 | 0.00022251 |   0.0 |  0.00
Modify  | 0.4518     | 0.4518     | 0.4518     |   0.0 |  0.36
Other   |            | 0.06278    |            |       |  0.05

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

Total # of neighbors = 127260
Ave neighs/atom = 63.63
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.416543435707, Press = -0.884088665109902
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -3633.9099     -3633.9099     -3716.9387     -3716.9387      321.32992      321.32992      42014.6        42014.6       -100.23178     -100.23178    
     69000  -3632.6856     -3632.6856     -3715.4978     -3715.4978      320.49187      320.49187      42036.413      42036.413     -24.730877     -24.730877    
Loop time of 124.099 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.696 ns/day, 34.472 hours/ns, 8.058 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.86     | 122.86     | 122.86     |   0.0 | 99.00
Neigh   | 0.61445    | 0.61445    | 0.61445    |   0.0 |  0.50
Comm    | 0.11086    | 0.11086    | 0.11086    |   0.0 |  0.09
Output  | 0.0004456  | 0.0004456  | 0.0004456  |   0.0 |  0.00
Modify  | 0.45022    | 0.45022    | 0.45022    |   0.0 |  0.36
Other   |            | 0.06262    |            |       |  0.05

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

Total # of neighbors = 127136
Ave neighs/atom = 63.568
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.424738474336, Press = -0.796415373645993
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -3632.6856     -3632.6856     -3715.4978     -3715.4978      320.49187      320.49187      42036.413      42036.413     -24.730877     -24.730877    
     70000  -3631.6062     -3631.6062     -3712.557      -3712.557       313.28803      313.28803      42085.824      42085.824     -256.04302     -256.04302    
Loop time of 124.066 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.696 ns/day, 34.463 hours/ns, 8.060 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.83     | 122.83     | 122.83     |   0.0 | 99.00
Neigh   | 0.61256    | 0.61256    | 0.61256    |   0.0 |  0.49
Comm    | 0.10983    | 0.10983    | 0.10983    |   0.0 |  0.09
Output  | 0.0001689  | 0.0001689  | 0.0001689  |   0.0 |  0.00
Modify  | 0.4511     | 0.4511     | 0.4511     |   0.0 |  0.36
Other   |            | 0.06215    |            |       |  0.05

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

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

Performance: 0.698 ns/day, 34.396 hours/ns, 8.076 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.59     | 122.59     | 122.59     |   0.0 | 99.00
Neigh   | 0.61766    | 0.61766    | 0.61766    |   0.0 |  0.50
Comm    | 0.11017    | 0.11017    | 0.11017    |   0.0 |  0.09
Output  | 0.00016928 | 0.00016928 | 0.00016928 |   0.0 |  0.00
Modify  | 0.45019    | 0.45019    | 0.45019    |   0.0 |  0.36
Other   |            | 0.06257    |            |       |  0.05

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

Total # of neighbors = 126938
Ave neighs/atom = 63.469
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.46539899833, Press = -0.827738332550971
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -3634.0851     -3634.0851     -3713.3179     -3713.3179      306.63906      306.63906      42113.992      42113.992     -275.56561     -275.56561    
     72000  -3627.2174     -3627.2174     -3711.7181     -3711.7181      327.02631      327.02631      42112.419      42112.419     -69.026431     -69.026431    
Loop time of 123.894 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.697 ns/day, 34.415 hours/ns, 8.071 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.65     | 122.65     | 122.65     |   0.0 | 99.00
Neigh   | 0.61329    | 0.61329    | 0.61329    |   0.0 |  0.50
Comm    | 0.1107     | 0.1107     | 0.1107     |   0.0 |  0.09
Output  | 0.00021083 | 0.00021083 | 0.00021083 |   0.0 |  0.00
Modify  | 0.45543    | 0.45543    | 0.45543    |   0.0 |  0.37
Other   |            | 0.06273    |            |       |  0.05

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

Total # of neighbors = 127322
Ave neighs/atom = 63.661
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.47518894828, Press = -1.09261408501005
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -3627.2174     -3627.2174     -3711.7181     -3711.7181      327.02631      327.02631      42112.419      42112.419     -69.026431     -69.026431    
     73000  -3634.1163     -3634.1163     -3713.8062     -3713.8062      308.40834      308.40834      41877.964      41877.964      459.17111      459.17111    
Loop time of 124.188 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.696 ns/day, 34.497 hours/ns, 8.052 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.97     | 122.97     | 122.97     |   0.0 | 99.02
Neigh   | 0.59023    | 0.59023    | 0.59023    |   0.0 |  0.48
Comm    | 0.11122    | 0.11122    | 0.11122    |   0.0 |  0.09
Output  | 0.00016899 | 0.00016899 | 0.00016899 |   0.0 |  0.00
Modify  | 0.45633    | 0.45633    | 0.45633    |   0.0 |  0.37
Other   |            | 0.06296    |            |       |  0.05

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

Total # of neighbors = 127542
Ave neighs/atom = 63.771
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.502888997537, Press = -0.607509194029869
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -3634.1163     -3634.1163     -3713.8062     -3713.8062      308.40834      308.40834      41877.964      41877.964      459.17111      459.17111    
     74000  -3627.5732     -3627.5732     -3710.2875     -3710.2875      320.11271      320.11271      42095.992      42095.992     -47.975199     -47.975199    
Loop time of 124.548 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.694 ns/day, 34.597 hours/ns, 8.029 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.31     | 123.31     | 123.31     |   0.0 | 99.00
Neigh   | 0.61579    | 0.61579    | 0.61579    |   0.0 |  0.49
Comm    | 0.1112     | 0.1112     | 0.1112     |   0.0 |  0.09
Output  | 0.00016867 | 0.00016867 | 0.00016867 |   0.0 |  0.00
Modify  | 0.4526     | 0.4526     | 0.4526     |   0.0 |  0.36
Other   |            | 0.06261    |            |       |  0.05

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

Total # of neighbors = 127564
Ave neighs/atom = 63.782
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.511100499147, Press = -0.0780377369932982
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -3627.5732     -3627.5732     -3710.2875     -3710.2875      320.11271      320.11271      42095.992      42095.992     -47.975199     -47.975199    
     75000  -3632.9985     -3632.9985     -3712.1305     -3712.1305      306.2488       306.2488       42291.433      42291.433     -911.20798     -911.20798    
Loop time of 124.122 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.696 ns/day, 34.478 hours/ns, 8.057 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.89     | 122.89     | 122.89     |   0.0 | 99.00
Neigh   | 0.61599    | 0.61599    | 0.61599    |   0.0 |  0.50
Comm    | 0.11066    | 0.11066    | 0.11066    |   0.0 |  0.09
Output  | 0.00016962 | 0.00016962 | 0.00016962 |   0.0 |  0.00
Modify  | 0.44745    | 0.44745    | 0.44745    |   0.0 |  0.36
Other   |            | 0.06267    |            |       |  0.05

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

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

Performance: 0.696 ns/day, 34.496 hours/ns, 8.053 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.95     | 122.95     | 122.95     |   0.0 | 99.00
Neigh   | 0.61935    | 0.61935    | 0.61935    |   0.0 |  0.50
Comm    | 0.11048    | 0.11048    | 0.11048    |   0.0 |  0.09
Output  | 0.00016972 | 0.00016972 | 0.00016972 |   0.0 |  0.00
Modify  | 0.44635    | 0.44635    | 0.44635    |   0.0 |  0.36
Other   |            | 0.06228    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.99     | 122.99     | 122.99     |   0.0 | 99.00
Neigh   | 0.62104    | 0.62104    | 0.62104    |   0.0 |  0.50
Comm    | 0.11081    | 0.11081    | 0.11081    |   0.0 |  0.09
Output  | 0.00016862 | 0.00016862 | 0.00016862 |   0.0 |  0.00
Modify  | 0.44951    | 0.44951    | 0.44951    |   0.0 |  0.36
Other   |            | 0.06197    |            |       |  0.05

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

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

Performance: 0.698 ns/day, 34.390 hours/ns, 8.077 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.59     | 122.59     | 122.59     |   0.0 | 99.02
Neigh   | 0.59675    | 0.59675    | 0.59675    |   0.0 |  0.48
Comm    | 0.10997    | 0.10997    | 0.10997    |   0.0 |  0.09
Output  | 0.00016868 | 0.00016868 | 0.00016868 |   0.0 |  0.00
Modify  | 0.44577    | 0.44577    | 0.44577    |   0.0 |  0.36
Other   |            | 0.06199    |            |       |  0.05

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

Total # of neighbors = 127244
Ave neighs/atom = 63.622
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.563709996613, Press = -0.566867693703565
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -3639.141      -3639.141      -3718.5176     -3718.5176      307.19572      307.19572      41900.96       41900.96       124.58992      124.58992    
     79000  -3632.6618     -3632.6618     -3712.6044     -3712.6044      309.38631      309.38631      42060.416      42060.416     -62.767659     -62.767659    
Loop time of 118.83 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.727 ns/day, 33.008 hours/ns, 8.415 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.68     | 117.68     | 117.68     |   0.0 | 99.03
Neigh   | 0.57061    | 0.57061    | 0.57061    |   0.0 |  0.48
Comm    | 0.10669    | 0.10669    | 0.10669    |   0.0 |  0.09
Output  | 0.00020318 | 0.00020318 | 0.00020318 |   0.0 |  0.00
Modify  | 0.41762    | 0.41762    | 0.41762    |   0.0 |  0.35
Other   |            | 0.0599     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3729 ave        3729 max        3729 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127264 ave      127264 max      127264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127264
Ave neighs/atom = 63.632
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.541369731315, Press = -0.314918709611829
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -3632.6618     -3632.6618     -3712.6044     -3712.6044      309.38631      309.38631      42060.416      42060.416     -62.767659     -62.767659    
     80000  -3629.4632     -3629.4632     -3710.9803     -3710.9803      315.47949      315.47949      42357.014      42357.014     -918.75717     -918.75717    
Loop time of 111.581 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.774 ns/day, 30.995 hours/ns, 8.962 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.51     | 110.51     | 110.51     |   0.0 | 99.04
Neigh   | 0.54876    | 0.54876    | 0.54876    |   0.0 |  0.49
Comm    | 0.09765    | 0.09765    | 0.09765    |   0.0 |  0.09
Output  | 0.00016854 | 0.00016854 | 0.00016854 |   0.0 |  0.00
Modify  | 0.36397    | 0.36397    | 0.36397    |   0.0 |  0.33
Other   |            | 0.05733    |            |       |  0.05

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

Total # of neighbors = 126906
Ave neighs/atom = 63.453
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.53877616953, Press = -0.489736910193832
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -3629.4632     -3629.4632     -3710.9803     -3710.9803      315.47949      315.47949      42357.014      42357.014     -918.75717     -918.75717    
     81000  -3634.9243     -3634.9243     -3714.2631     -3714.2631      307.04938      307.04938      42007.48       42007.48      -87.041501     -87.041501    
Loop time of 110.842 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.779 ns/day, 30.790 hours/ns, 9.022 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.76     | 109.76     | 109.76     |   0.0 | 99.02
Neigh   | 0.57095    | 0.57095    | 0.57095    |   0.0 |  0.52
Comm    | 0.097081   | 0.097081   | 0.097081   |   0.0 |  0.09
Output  | 0.00016975 | 0.00016975 | 0.00016975 |   0.0 |  0.00
Modify  | 0.3574     | 0.3574     | 0.3574     |   0.0 |  0.32
Other   |            | 0.05634    |            |       |  0.05

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

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

Performance: 0.779 ns/day, 30.799 hours/ns, 9.019 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.79     | 109.79     | 109.79     |   0.0 | 99.02
Neigh   | 0.57214    | 0.57214    | 0.57214    |   0.0 |  0.52
Comm    | 0.097357   | 0.097357   | 0.097357   |   0.0 |  0.09
Output  | 0.00016912 | 0.00016912 | 0.00016912 |   0.0 |  0.00
Modify  | 0.35811    | 0.35811    | 0.35811    |   0.0 |  0.32
Other   |            | 0.05655    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.11     | 110.11     | 110.11     |   0.0 | 99.05
Neigh   | 0.54709    | 0.54709    | 0.54709    |   0.0 |  0.49
Comm    | 0.097107   | 0.097107   | 0.097107   |   0.0 |  0.09
Output  | 0.00016814 | 0.00016814 | 0.00016814 |   0.0 |  0.00
Modify  | 0.35728    | 0.35728    | 0.35728    |   0.0 |  0.32
Other   |            | 0.05698    |            |       |  0.05

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

Total # of neighbors = 127138
Ave neighs/atom = 63.569
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.492988470297, Press = -0.147630055340237
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -3634.1716     -3634.1716     -3714.4626     -3714.4626      310.7343       310.7343       42063.256      42063.256     -160.71348     -160.71348    
     84000  -3634.8567     -3634.8567     -3715.4511     -3715.4511      311.90852      311.90852      42040.251      42040.251     -129.57871     -129.57871    
Loop time of 110.768 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.780 ns/day, 30.769 hours/ns, 9.028 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.68     | 109.68     | 109.68     |   0.0 | 99.02
Neigh   | 0.57156    | 0.57156    | 0.57156    |   0.0 |  0.52
Comm    | 0.09834    | 0.09834    | 0.09834    |   0.0 |  0.09
Output  | 0.00016959 | 0.00016959 | 0.00016959 |   0.0 |  0.00
Modify  | 0.35804    | 0.35804    | 0.35804    |   0.0 |  0.32
Other   |            | 0.05705    |            |       |  0.05

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

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

Performance: 0.778 ns/day, 30.855 hours/ns, 9.003 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.99     | 109.99     | 109.99     |   0.0 | 99.02
Neigh   | 0.57048    | 0.57048    | 0.57048    |   0.0 |  0.51
Comm    | 0.096772   | 0.096772   | 0.096772   |   0.0 |  0.09
Output  | 0.00020935 | 0.00020935 | 0.00020935 |   0.0 |  0.00
Modify  | 0.35841    | 0.35841    | 0.35841    |   0.0 |  0.32
Other   |            | 0.05716    |            |       |  0.05

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

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

Performance: 0.775 ns/day, 30.976 hours/ns, 8.967 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.42     | 110.42     | 110.42     |   0.0 | 99.02
Neigh   | 0.574      | 0.574      | 0.574      |   0.0 |  0.51
Comm    | 0.097771   | 0.097771   | 0.097771   |   0.0 |  0.09
Output  | 0.00016724 | 0.00016724 | 0.00016724 |   0.0 |  0.00
Modify  | 0.36306    | 0.36306    | 0.36306    |   0.0 |  0.33
Other   |            | 0.05761    |            |       |  0.05

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

Total # of neighbors = 127978
Ave neighs/atom = 63.989
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.428223989766, Press = -0.186800957047024
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -3635.4554     -3635.4554     -3715.0599     -3715.0599      308.07737      308.07737      41782.989      41782.989      609.3387       609.3387     
     87000  -3632.1433     -3632.1433     -3714.1752     -3714.1752      317.47166      317.47166      42112.085      42112.085     -295.96324     -295.96324    
Loop time of 110.246 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.784 ns/day, 30.624 hours/ns, 9.071 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.17     | 109.17     | 109.17     |   0.0 | 99.02
Neigh   | 0.56663    | 0.56663    | 0.56663    |   0.0 |  0.51
Comm    | 0.096951   | 0.096951   | 0.096951   |   0.0 |  0.09
Output  | 0.00021165 | 0.00021165 | 0.00021165 |   0.0 |  0.00
Modify  | 0.35596    | 0.35596    | 0.35596    |   0.0 |  0.32
Other   |            | 0.05682    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3815 ave        3815 max        3815 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127266 ave      127266 max      127266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127266
Ave neighs/atom = 63.633
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.426921494501, Press = -0.390390992157616
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -3632.1433     -3632.1433     -3714.1752     -3714.1752      317.47166      317.47166      42112.085      42112.085     -295.96324     -295.96324    
     88000  -3632.4354     -3632.4354     -3713.8898     -3713.8898      315.237        315.237        42162.726      42162.726     -428.42983     -428.42983    
Loop time of 110.201 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.784 ns/day, 30.611 hours/ns, 9.074 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.13     | 109.13     | 109.13     |   0.0 | 99.03
Neigh   | 0.56561    | 0.56561    | 0.56561    |   0.0 |  0.51
Comm    | 0.097161   | 0.097161   | 0.097161   |   0.0 |  0.09
Output  | 0.00020297 | 0.00020297 | 0.00020297 |   0.0 |  0.00
Modify  | 0.35445    | 0.35445    | 0.35445    |   0.0 |  0.32
Other   |            | 0.05639    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3759 ave        3759 max        3759 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126990 ave      126990 max      126990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126990
Ave neighs/atom = 63.495
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.434470940506, Press = -0.63375105759994
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -3632.4354     -3632.4354     -3713.8898     -3713.8898      315.237        315.237        42162.726      42162.726     -428.42983     -428.42983    
     89000  -3630.5156     -3630.5156     -3712.0984     -3712.0984      315.73395      315.73395      41969.737      41969.737      267.70557      267.70557    
Loop time of 110.688 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.781 ns/day, 30.747 hours/ns, 9.034 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.63     | 109.63     | 109.63     |   0.0 | 99.04
Neigh   | 0.54595    | 0.54595    | 0.54595    |   0.0 |  0.49
Comm    | 0.09732    | 0.09732    | 0.09732    |   0.0 |  0.09
Output  | 0.00016993 | 0.00016993 | 0.00016993 |   0.0 |  0.00
Modify  | 0.35882    | 0.35882    | 0.35882    |   0.0 |  0.32
Other   |            | 0.05714    |            |       |  0.05

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

Total # of neighbors = 127468
Ave neighs/atom = 63.734
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.458840542029, Press = -0.951386403223069
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -3630.5156     -3630.5156     -3712.0984     -3712.0984      315.73395      315.73395      41969.737      41969.737      267.70557      267.70557    
     90000  -3630.8579     -3630.8579     -3714.4481     -3714.4481      323.50285      323.50285      41951.18       41951.18       315.8261       315.8261     
Loop time of 110.867 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.779 ns/day, 30.796 hours/ns, 9.020 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.79     | 109.79     | 109.79     |   0.0 | 99.02
Neigh   | 0.56933    | 0.56933    | 0.56933    |   0.0 |  0.51
Comm    | 0.097853   | 0.097853   | 0.097853   |   0.0 |  0.09
Output  | 0.00021139 | 0.00021139 | 0.00021139 |   0.0 |  0.00
Modify  | 0.3571     | 0.3571     | 0.3571     |   0.0 |  0.32
Other   |            | 0.05661    |            |       |  0.05

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

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

Performance: 0.782 ns/day, 30.705 hours/ns, 9.047 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.44     | 109.44     | 109.44     |   0.0 | 99.00
Neigh   | 0.59283    | 0.59283    | 0.59283    |   0.0 |  0.54
Comm    | 0.097157   | 0.097157   | 0.097157   |   0.0 |  0.09
Output  | 0.0001684  | 0.0001684  | 0.0001684  |   0.0 |  0.00
Modify  | 0.35463    | 0.35463    | 0.35463    |   0.0 |  0.32
Other   |            | 0.05636    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3803 ave        3803 max        3803 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126928 ave      126928 max      126928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.783 ns/day, 30.641 hours/ns, 9.065 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.21     | 109.21     | 109.21     |   0.0 | 99.00
Neigh   | 0.5922     | 0.5922     | 0.5922     |   0.0 |  0.54
Comm    | 0.097842   | 0.097842   | 0.097842   |   0.0 |  0.09
Output  | 0.00016911 | 0.00016911 | 0.00016911 |   0.0 |  0.00
Modify  | 0.35548    | 0.35548    | 0.35548    |   0.0 |  0.32
Other   |            | 0.05636    |            |       |  0.05

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

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

Performance: 0.782 ns/day, 30.687 hours/ns, 9.052 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.42     | 109.42     | 109.42     |   0.0 | 99.05
Neigh   | 0.54272    | 0.54272    | 0.54272    |   0.0 |  0.49
Comm    | 0.095994   | 0.095994   | 0.095994   |   0.0 |  0.09
Output  | 0.0001686  | 0.0001686  | 0.0001686  |   0.0 |  0.00
Modify  | 0.3554     | 0.3554     | 0.3554     |   0.0 |  0.32
Other   |            | 0.05614    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3827 ave        3827 max        3827 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127484 ave      127484 max      127484 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127484
Ave neighs/atom = 63.742
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.392953605546, Press = -0.479929357355004
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -3632.3985     -3632.3985     -3712.8015     -3712.8015      311.16778      311.16778      41898.695      41898.695      498.12685      498.12685    
     94000  -3633.6304     -3633.6304     -3712.7105     -3712.7105      306.04802      306.04802      41944.77       41944.77       274.04072      274.04072    
Loop time of 110.472 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.782 ns/day, 30.687 hours/ns, 9.052 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.4      | 109.4      | 109.4      |   0.0 | 99.03
Neigh   | 0.56718    | 0.56718    | 0.56718    |   0.0 |  0.51
Comm    | 0.096643   | 0.096643   | 0.096643   |   0.0 |  0.09
Output  | 0.00016869 | 0.00016869 | 0.00016869 |   0.0 |  0.00
Modify  | 0.35483    | 0.35483    | 0.35483    |   0.0 |  0.32
Other   |            | 0.05624    |            |       |  0.05

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

Total # of neighbors = 127524
Ave neighs/atom = 63.762
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.381343320051, Press = -0.434105348086597
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -3633.6304     -3633.6304     -3712.7105     -3712.7105      306.04802      306.04802      41944.77       41944.77       274.04072      274.04072    
     95000  -3629.1989     -3629.1989     -3710.2581     -3710.2581      313.70748      313.70748      42151.648      42151.648     -231.77085     -231.77085    
Loop time of 110.297 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.24     | 109.24     | 109.24     |   0.0 | 99.05
Neigh   | 0.54392    | 0.54392    | 0.54392    |   0.0 |  0.49
Comm    | 0.097139   | 0.097139   | 0.097139   |   0.0 |  0.09
Output  | 0.00020878 | 0.00020878 | 0.00020878 |   0.0 |  0.00
Modify  | 0.35573    | 0.35573    | 0.35573    |   0.0 |  0.32
Other   |            | 0.05612    |            |       |  0.05

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

Total # of neighbors = 127332
Ave neighs/atom = 63.666
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.386269871641, Press = -0.368303595493141
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -3629.1989     -3629.1989     -3710.2581     -3710.2581      313.70748      313.70748      42151.648      42151.648     -231.77085     -231.77085    
     96000  -3633.7111     -3633.7111     -3714.2353     -3714.2353      311.63696      311.63696      42131.12       42131.12      -303.65749     -303.65749    
Loop time of 119.12 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.089 hours/ns, 8.395 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.93     | 117.93     | 117.93     |   0.0 | 99.00
Neigh   | 0.60037    | 0.60037    | 0.60037    |   0.0 |  0.50
Comm    | 0.10671    | 0.10671    | 0.10671    |   0.0 |  0.09
Output  | 0.00020705 | 0.00020705 | 0.00020705 |   0.0 |  0.00
Modify  | 0.41825    | 0.41825    | 0.41825    |   0.0 |  0.35
Other   |            | 0.05982    |            |       |  0.05

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

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

Performance: 0.695 ns/day, 34.511 hours/ns, 8.049 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.99     | 122.99     | 122.99     |   0.0 | 99.00
Neigh   | 0.61889    | 0.61889    | 0.61889    |   0.0 |  0.50
Comm    | 0.11072    | 0.11072    | 0.11072    |   0.0 |  0.09
Output  | 0.00022148 | 0.00022148 | 0.00022148 |   0.0 |  0.00
Modify  | 0.45376    | 0.45376    | 0.45376    |   0.0 |  0.37
Other   |            | 0.06237    |            |       |  0.05

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

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

Performance: 0.693 ns/day, 34.622 hours/ns, 8.023 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    | 123.42     | 123.42     | 123.42     |   0.0 | 99.02
Neigh   | 0.59277    | 0.59277    | 0.59277    |   0.0 |  0.48
Comm    | 0.11148    | 0.11148    | 0.11148    |   0.0 |  0.09
Output  | 0.00020565 | 0.00020565 | 0.00020565 |   0.0 |  0.00
Modify  | 0.45086    | 0.45086    | 0.45086    |   0.0 |  0.36
Other   |            | 0.06253    |            |       |  0.05

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

Total # of neighbors = 127732
Ave neighs/atom = 63.866
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.398236780361, Press = -0.335920294694178
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -3630.5888     -3630.5888     -3713.5031     -3713.5031      320.88695      320.88695      41942.355      41942.355      274.45476      274.45476    
     99000  -3632.9881     -3632.9881     -3712.2235     -3712.2235      306.64944      306.64944      42061.044      42061.044     -116.38223     -116.38223    
Loop time of 124.401 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.695 ns/day, 34.556 hours/ns, 8.039 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    | 123.18     | 123.18     | 123.18     |   0.0 | 99.02
Neigh   | 0.59051    | 0.59051    | 0.59051    |   0.0 |  0.47
Comm    | 0.11095    | 0.11095    | 0.11095    |   0.0 |  0.09
Output  | 0.00020661 | 0.00020661 | 0.00020661 |   0.0 |  0.00
Modify  | 0.45259    | 0.45259    | 0.45259    |   0.0 |  0.36
Other   |            | 0.06197    |            |       |  0.05

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

Total # of neighbors = 127232
Ave neighs/atom = 63.616
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.399205069254, Press = -0.33351144923029
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -3632.9881     -3632.9881     -3712.2235     -3712.2235      306.64944      306.64944      42061.044      42061.044     -116.38223     -116.38223    
    100000  -3629.9812     -3629.9812     -3712.3028     -3712.3028      318.59336      318.59336      42127.382      42127.382     -258.95015     -258.95015    
Loop time of 123.911 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.697 ns/day, 34.420 hours/ns, 8.070 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.67     | 122.67     | 122.67     |   0.0 | 99.00
Neigh   | 0.61551    | 0.61551    | 0.61551    |   0.0 |  0.50
Comm    | 0.11116    | 0.11116    | 0.11116    |   0.0 |  0.09
Output  | 0.00020529 | 0.00020529 | 0.00020529 |   0.0 |  0.00
Modify  | 0.44965    | 0.44965    | 0.44965    |   0.0 |  0.36
Other   |            | 0.06192    |            |       |  0.05

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

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

Performance: 0.744 ns/day, 32.248 hours/ns, 8.614 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 114.95     | 114.95     | 114.95     |   0.0 | 99.02
Neigh   | 0.58462    | 0.58462    | 0.58462    |   0.0 |  0.50
Comm    | 0.10226    | 0.10226    | 0.10226    |   0.0 |  0.09
Output  | 0.00016674 | 0.00016674 | 0.00016674 |   0.0 |  0.00
Modify  | 0.39682    | 0.39682    | 0.39682    |   0.0 |  0.34
Other   |            | 0.05901    |            |       |  0.05

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

Total # of neighbors = 127140
Ave neighs/atom = 63.57
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.406919373678, Press = -0.692842656999816
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -3634.2551     -3634.2551     -3715.8745     -3715.8745      315.87528      315.87528      41997.214      41997.214      34.629601      34.629601    
    102000  -3629.6736     -3629.6736     -3714.3471     -3714.3471      327.69533      327.69533      41893.311      41893.311      462.08752      462.08752    
Loop time of 110.499 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.782 ns/day, 30.694 hours/ns, 9.050 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.42     | 109.42     | 109.42     |   0.0 | 99.02
Neigh   | 0.56841    | 0.56841    | 0.56841    |   0.0 |  0.51
Comm    | 0.098596   | 0.098596   | 0.098596   |   0.0 |  0.09
Output  | 0.00017003 | 0.00017003 | 0.00017003 |   0.0 |  0.00
Modify  | 0.35882    | 0.35882    | 0.35882    |   0.0 |  0.32
Other   |            | 0.05671    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3825 ave        3825 max        3825 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127668 ave      127668 max      127668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.781 ns/day, 30.717 hours/ns, 9.043 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.5      | 109.5      | 109.5      |   0.0 | 99.02
Neigh   | 0.5692     | 0.5692     | 0.5692     |   0.0 |  0.51
Comm    | 0.097548   | 0.097548   | 0.097548   |   0.0 |  0.09
Output  | 0.00016914 | 0.00016914 | 0.00016914 |   0.0 |  0.00
Modify  | 0.3578     | 0.3578     | 0.3578     |   0.0 |  0.32
Other   |            | 0.05659    |            |       |  0.05

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

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

Performance: 0.781 ns/day, 30.723 hours/ns, 9.041 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.54     | 109.54     | 109.54     |   0.0 | 99.04
Neigh   | 0.54287    | 0.54287    | 0.54287    |   0.0 |  0.49
Comm    | 0.098812   | 0.098812   | 0.098812   |   0.0 |  0.09
Output  | 0.00017029 | 0.00017029 | 0.00017029 |   0.0 |  0.00
Modify  | 0.36043    | 0.36043    | 0.36043    |   0.0 |  0.33
Other   |            | 0.05681    |            |       |  0.05

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

Total # of neighbors = 127104
Ave neighs/atom = 63.552
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.425744453013, Press = -0.234013942235578
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    104000  -3634.7748     -3634.7748     -3713.5666     -3713.5666      304.9326       304.9326       42163.625      42163.625     -561.44771     -561.44771    
    105000  -3631.835      -3631.835      -3712.3415     -3712.3415      311.56838      311.56838      42041.327      42041.327      46.57761       46.57761     
Loop time of 110.597 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.781 ns/day, 30.722 hours/ns, 9.042 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.54     | 109.54     | 109.54     |   0.0 | 99.05
Neigh   | 0.54349    | 0.54349    | 0.54349    |   0.0 |  0.49
Comm    | 0.097836   | 0.097836   | 0.097836   |   0.0 |  0.09
Output  | 0.0002074  | 0.0002074  | 0.0002074  |   0.0 |  0.00
Modify  | 0.35791    | 0.35791    | 0.35791    |   0.0 |  0.32
Other   |            | 0.05646    |            |       |  0.05

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

Total # of neighbors = 127128
Ave neighs/atom = 63.564
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.401674073113, Press = -0.479944135924454
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    105000  -3631.835      -3631.835      -3712.3415     -3712.3415      311.56838      311.56838      42041.327      42041.327      46.57761       46.57761     
    106000  -3636.0373     -3636.0373     -3715.7039     -3715.7039      308.318        308.318        41930.934      41930.934      322.29311      322.29311    
Loop time of 110.54 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.782 ns/day, 30.706 hours/ns, 9.047 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.48     | 109.48     | 109.48     |   0.0 | 99.04
Neigh   | 0.54422    | 0.54422    | 0.54422    |   0.0 |  0.49
Comm    | 0.098244   | 0.098244   | 0.098244   |   0.0 |  0.09
Output  | 0.00016851 | 0.00016851 | 0.00016851 |   0.0 |  0.00
Modify  | 0.35877    | 0.35877    | 0.35877    |   0.0 |  0.32
Other   |            | 0.05689    |            |       |  0.05

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

Total # of neighbors = 127454
Ave neighs/atom = 63.727
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.388068505613, Press = -0.45854457029466
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    106000  -3636.0373     -3636.0373     -3715.7039     -3715.7039      308.318        308.318        41930.934      41930.934      322.29311      322.29311    
    107000  -3630.6997     -3630.6997     -3710.9944     -3710.9944      310.74858      310.74858      42004.838      42004.838      103.06608      103.06608    
Loop time of 110.399 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.783 ns/day, 30.666 hours/ns, 9.058 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.35     | 109.35     | 109.35     |   0.0 | 99.05
Neigh   | 0.54325    | 0.54325    | 0.54325    |   0.0 |  0.49
Comm    | 0.098134   | 0.098134   | 0.098134   |   0.0 |  0.09
Output  | 0.0001683  | 0.0001683  | 0.0001683  |   0.0 |  0.00
Modify  | 0.35595    | 0.35595    | 0.35595    |   0.0 |  0.32
Other   |            | 0.05665    |            |       |  0.05

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

Total # of neighbors = 127594
Ave neighs/atom = 63.797
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.383977367385, Press = -0.377245104205976
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    107000  -3630.6997     -3630.6997     -3710.9944     -3710.9944      310.74858      310.74858      42004.838      42004.838      103.06608      103.06608    
    108000  -3632.4045     -3632.4045     -3713.0134     -3713.0134      311.96481      311.96481      42066.827      42066.827     -154.25363     -154.25363    
Loop time of 111.413 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.775 ns/day, 30.948 hours/ns, 8.976 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.33     | 110.33     | 110.33     |   0.0 | 99.03
Neigh   | 0.56936    | 0.56936    | 0.56936    |   0.0 |  0.51
Comm    | 0.09819    | 0.09819    | 0.09819    |   0.0 |  0.09
Output  | 0.00016748 | 0.00016748 | 0.00016748 |   0.0 |  0.00
Modify  | 0.36063    | 0.36063    | 0.36063    |   0.0 |  0.32
Other   |            | 0.0567     |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.11     | 109.11     | 109.11     |   0.0 | 99.03
Neigh   | 0.56589    | 0.56589    | 0.56589    |   0.0 |  0.51
Comm    | 0.096084   | 0.096084   | 0.096084   |   0.0 |  0.09
Output  | 0.00016834 | 0.00016834 | 0.00016834 |   0.0 |  0.00
Modify  | 0.35448    | 0.35448    | 0.35448    |   0.0 |  0.32
Other   |            | 0.0557     |            |       |  0.05

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

Total # of neighbors = 127112
Ave neighs/atom = 63.556
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.409655355669, Press = -0.57156061116802
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    109000  -3633.2507     -3633.2507     -3712.0419     -3712.0419      304.93008      304.93008      42093.267      42093.267     -242.56294     -242.56294    
    110000  -3629.6775     -3629.6775     -3711.6417     -3711.6417      317.21003      317.21003      41986.796      41986.796      174.25771      174.25771    
Loop time of 110.332 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.28     | 109.28     | 109.28     |   0.0 | 99.05
Neigh   | 0.54337    | 0.54337    | 0.54337    |   0.0 |  0.49
Comm    | 0.095907   | 0.095907   | 0.095907   |   0.0 |  0.09
Output  | 0.00016861 | 0.00016861 | 0.00016861 |   0.0 |  0.00
Modify  | 0.3549     | 0.3549     | 0.3549     |   0.0 |  0.32
Other   |            | 0.05696    |            |       |  0.05

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

Total # of neighbors = 127456
Ave neighs/atom = 63.728
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.418996617416, Press = -0.565612073668291
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    110000  -3629.6775     -3629.6775     -3711.6417     -3711.6417      317.21003      317.21003      41986.796      41986.796      174.25771      174.25771    
    111000  -3635.235      -3635.235      -3716.1009     -3716.1009      312.95923      312.95923      41857.651      41857.651      491.82586      491.82586    
Loop time of 110.731 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.780 ns/day, 30.759 hours/ns, 9.031 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.65     | 109.65     | 109.65     |   0.0 | 99.03
Neigh   | 0.56808    | 0.56808    | 0.56808    |   0.0 |  0.51
Comm    | 0.09621    | 0.09621    | 0.09621    |   0.0 |  0.09
Output  | 0.00021299 | 0.00021299 | 0.00021299 |   0.0 |  0.00
Modify  | 0.35571    | 0.35571    | 0.35571    |   0.0 |  0.32
Other   |            | 0.05688    |            |       |  0.05

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

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

Performance: 0.733 ns/day, 32.762 hours/ns, 8.479 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.78     | 116.78     | 116.78     |   0.0 | 99.01
Neigh   | 0.59386    | 0.59386    | 0.59386    |   0.0 |  0.50
Comm    | 0.10512    | 0.10512    | 0.10512    |   0.0 |  0.09
Output  | 0.00017009 | 0.00017009 | 0.00017009 |   0.0 |  0.00
Modify  | 0.40852    | 0.40852    | 0.40852    |   0.0 |  0.35
Other   |            | 0.05917    |            |       |  0.05

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

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

Performance: 0.779 ns/day, 30.808 hours/ns, 9.016 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.82     | 109.82     | 109.82     |   0.0 | 99.02
Neigh   | 0.57139    | 0.57139    | 0.57139    |   0.0 |  0.52
Comm    | 0.098791   | 0.098791   | 0.098791   |   0.0 |  0.09
Output  | 0.00016594 | 0.00016594 | 0.00016594 |   0.0 |  0.00
Modify  | 0.3609     | 0.3609     | 0.3609     |   0.0 |  0.33
Other   |            | 0.0561     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3664 ave        3664 max        3664 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126676 ave      126676 max      126676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.778 ns/day, 30.832 hours/ns, 9.010 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.92     | 109.92     | 109.92     |   0.0 | 99.03
Neigh   | 0.54868    | 0.54868    | 0.54868    |   0.0 |  0.49
Comm    | 0.099343   | 0.099343   | 0.099343   |   0.0 |  0.09
Output  | 0.00017197 | 0.00017197 | 0.00017197 |   0.0 |  0.00
Modify  | 0.36608    | 0.36608    | 0.36608    |   0.0 |  0.33
Other   |            | 0.05704    |            |       |  0.05

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

Total # of neighbors = 127442
Ave neighs/atom = 63.721
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.432489583144, Press = -0.634906992078301
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    114000  -3630.0909     -3630.0909     -3713.0078     -3713.0078      320.89687      320.89687      42008.404      42008.404      66.993421      66.993421    
    115000  -3634.1243     -3634.1243     -3715.5226     -3715.5226      315.01976      315.01976      41922.906      41922.906      260.96851      260.96851    
Loop time of 110.392 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.35     | 109.35     | 109.35     |   0.0 | 99.05
Neigh   | 0.54261    | 0.54261    | 0.54261    |   0.0 |  0.49
Comm    | 0.095738   | 0.095738   | 0.095738   |   0.0 |  0.09
Output  | 0.0001709  | 0.0001709  | 0.0001709  |   0.0 |  0.00
Modify  | 0.35212    | 0.35212    | 0.35212    |   0.0 |  0.32
Other   |            | 0.05668    |            |       |  0.05

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

Total # of neighbors = 127572
Ave neighs/atom = 63.786
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.433464507251, Press = -0.273125171561007
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    115000  -3634.1243     -3634.1243     -3715.5226     -3715.5226      315.01976      315.01976      41922.906      41922.906      260.96851      260.96851    
    116000  -3630.2854     -3630.2854     -3713.6808     -3713.6808      322.74875      322.74875      42161.344      42161.344     -469.83074     -469.83074    
Loop time of 110.321 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.25     | 109.25     | 109.25     |   0.0 | 99.03
Neigh   | 0.56783    | 0.56783    | 0.56783    |   0.0 |  0.51
Comm    | 0.096348   | 0.096348   | 0.096348   |   0.0 |  0.09
Output  | 0.00016836 | 0.00016836 | 0.00016836 |   0.0 |  0.00
Modify  | 0.35247    | 0.35247    | 0.35247    |   0.0 |  0.32
Other   |            | 0.05732    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3804 ave        3804 max        3804 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127138 ave      127138 max      127138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127138
Ave neighs/atom = 63.569
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.432119412218, Press = -0.132051627018614
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    116000  -3630.2854     -3630.2854     -3713.6808     -3713.6808      322.74875      322.74875      42161.344      42161.344     -469.83074     -469.83074    
    117000  -3634.8396     -3634.8396     -3714.448      -3714.448       308.09263      308.09263      42232.976      42232.976     -755.8129      -755.8129     
Loop time of 116.951 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.739 ns/day, 32.486 hours/ns, 8.551 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.8      | 115.8      | 115.8      |   0.0 | 99.01
Neigh   | 0.59259    | 0.59259    | 0.59259    |   0.0 |  0.51
Comm    | 0.10298    | 0.10298    | 0.10298    |   0.0 |  0.09
Output  | 0.00017075 | 0.00017075 | 0.00017075 |   0.0 |  0.00
Modify  | 0.39933    | 0.39933    | 0.39933    |   0.0 |  0.34
Other   |            | 0.05921    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3702 ave        3702 max        3702 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126712 ave      126712 max      126712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.696 ns/day, 34.459 hours/ns, 8.061 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.84     | 122.84     | 122.84     |   0.0 | 99.02
Neigh   | 0.59058    | 0.59058    | 0.59058    |   0.0 |  0.48
Comm    | 0.10998    | 0.10998    | 0.10998    |   0.0 |  0.09
Output  | 0.00021965 | 0.00021965 | 0.00021965 |   0.0 |  0.00
Modify  | 0.44672    | 0.44672    | 0.44672    |   0.0 |  0.36
Other   |            | 0.06283    |            |       |  0.05

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

Total # of neighbors = 127502
Ave neighs/atom = 63.751
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.4323521201, Press = -0.497667071703147
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    118000  -3631.9073     -3631.9073     -3711.1233     -3711.1233      306.57397      306.57397      41895.649      41895.649      430.88072      430.88072    
    119000  -3635.3295     -3635.3295     -3713.0797     -3713.0797      300.90163      300.90163      41900.307      41900.307      346.5993       346.5993     
Loop time of 122.979 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.76     | 121.76     | 121.76     |   0.0 | 99.01
Neigh   | 0.60765    | 0.60765    | 0.60765    |   0.0 |  0.49
Comm    | 0.10876    | 0.10876    | 0.10876    |   0.0 |  0.09
Output  | 0.00016966 | 0.00016966 | 0.00016966 |   0.0 |  0.00
Modify  | 0.44236    | 0.44236    | 0.44236    |   0.0 |  0.36
Other   |            | 0.0622     |            |       |  0.05

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

Total # of neighbors = 127672
Ave neighs/atom = 63.836
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.435821755425, Press = -0.230617399251573
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    119000  -3635.3295     -3635.3295     -3713.0797     -3713.0797      300.90163      300.90163      41900.307      41900.307      346.5993       346.5993     
    120000  -3632.6448     -3632.6448     -3713.8215     -3713.8215      314.16236      314.16236      42011.267      42011.267      26.61338       26.61338     
Loop time of 116.336 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.743 ns/day, 32.316 hours/ns, 8.596 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.18     | 115.18     | 115.18     |   0.0 | 99.01
Neigh   | 0.59284    | 0.59284    | 0.59284    |   0.0 |  0.51
Comm    | 0.10368    | 0.10368    | 0.10368    |   0.0 |  0.09
Output  | 0.00020328 | 0.00020328 | 0.00020328 |   0.0 |  0.00
Modify  | 0.39764    | 0.39764    | 0.39764    |   0.0 |  0.34
Other   |            | 0.05861    |            |       |  0.05

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

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

Performance: 0.730 ns/day, 32.893 hours/ns, 8.445 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.25     | 117.25     | 117.25     |   0.0 | 99.02
Neigh   | 0.58888    | 0.58888    | 0.58888    |   0.0 |  0.50
Comm    | 0.1057     | 0.1057     | 0.1057     |   0.0 |  0.09
Output  | 0.00016815 | 0.00016815 | 0.00016815 |   0.0 |  0.00
Modify  | 0.40967    | 0.40967    | 0.40967    |   0.0 |  0.35
Other   |            | 0.05993    |            |       |  0.05

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

Total # of neighbors = 127342
Ave neighs/atom = 63.671
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.426518655634, Press = -0.261883196774291
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    121000  -3634.0735     -3634.0735     -3715.6045     -3715.6045      315.53348      315.53348      41957.36       41957.36       41.478165      41.478165    
    122000  -3628.5528     -3628.5528     -3712.7203     -3712.7203      325.73683      325.73683      42049.6        42049.6        48.275114      48.275114    
Loop time of 118.176 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.731 ns/day, 32.827 hours/ns, 8.462 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.03     | 117.03     | 117.03     |   0.0 | 99.03
Neigh   | 0.57031    | 0.57031    | 0.57031    |   0.0 |  0.48
Comm    | 0.10527    | 0.10527    | 0.10527    |   0.0 |  0.09
Output  | 0.00016846 | 0.00016846 | 0.00016846 |   0.0 |  0.00
Modify  | 0.40978    | 0.40978    | 0.40978    |   0.0 |  0.35
Other   |            | 0.05946    |            |       |  0.05

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

Total # of neighbors = 127416
Ave neighs/atom = 63.708
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.438612870475, Press = -0.0771321680028862
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    122000  -3628.5528     -3628.5528     -3712.7203     -3712.7203      325.73683      325.73683      42049.6        42049.6        48.275114      48.275114    
    123000  -3633.8688     -3633.8688     -3713.0143     -3713.0143      306.30113      306.30113      42148.024      42148.024     -422.4157      -422.4157     
Loop time of 120.495 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.717 ns/day, 33.471 hours/ns, 8.299 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.29     | 119.29     | 119.29     |   0.0 | 99.00
Neigh   | 0.60215    | 0.60215    | 0.60215    |   0.0 |  0.50
Comm    | 0.10826    | 0.10826    | 0.10826    |   0.0 |  0.09
Output  | 0.00017159 | 0.00017159 | 0.00017159 |   0.0 |  0.00
Modify  | 0.43382    | 0.43382    | 0.43382    |   0.0 |  0.36
Other   |            | 0.06131    |            |       |  0.05

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

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

Performance: 0.733 ns/day, 32.743 hours/ns, 8.483 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.71     | 116.71     | 116.71     |   0.0 | 99.01
Neigh   | 0.59236    | 0.59236    | 0.59236    |   0.0 |  0.50
Comm    | 0.10534    | 0.10534    | 0.10534    |   0.0 |  0.09
Output  | 0.00047969 | 0.00047969 | 0.00047969 |   0.0 |  0.00
Modify  | 0.40821    | 0.40821    | 0.40821    |   0.0 |  0.35
Other   |            | 0.0588     |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.28     | 120.28     | 120.28     |   0.0 | 99.01
Neigh   | 0.60677    | 0.60677    | 0.60677    |   0.0 |  0.50
Comm    | 0.10799    | 0.10799    | 0.10799    |   0.0 |  0.09
Output  | 0.00016863 | 0.00016863 | 0.00016863 |   0.0 |  0.00
Modify  | 0.42943    | 0.42943    | 0.42943    |   0.0 |  0.35
Other   |            | 0.06135    |            |       |  0.05

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

Total # of neighbors = 127756
Ave neighs/atom = 63.878
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.418810560089, Press = -0.322484482848089
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    125000  -3631.2599     -3631.2599     -3713.0365     -3713.0365      316.4839       316.4839       41882.057      41882.057      483.65937      483.65937    
    126000  -3636.5358     -3636.5358     -3715.5188     -3715.5188      305.67231      305.67231      42042.079      42042.079     -217.5067      -217.5067     
Loop time of 111.676 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.774 ns/day, 31.021 hours/ns, 8.954 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.61     | 110.61     | 110.61     |   0.0 | 99.05
Neigh   | 0.54365    | 0.54365    | 0.54365    |   0.0 |  0.49
Comm    | 0.097803   | 0.097803   | 0.097803   |   0.0 |  0.09
Output  | 0.00020694 | 0.00020694 | 0.00020694 |   0.0 |  0.00
Modify  | 0.36273    | 0.36273    | 0.36273    |   0.0 |  0.32
Other   |            | 0.05719    |            |       |  0.05

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

Total # of neighbors = 127762
Ave neighs/atom = 63.881
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.408341785091, Press = 0.267500470620262
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    126000  -3636.5358     -3636.5358     -3715.5188     -3715.5188      305.67231      305.67231      42042.079      42042.079     -217.5067      -217.5067     
    127000  -3633.5284     -3633.5284     -3714.0565     -3714.0565      311.65216      311.65216      42268.505      42268.505     -819.83671     -819.83671    
Loop time of 111.925 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.772 ns/day, 31.090 hours/ns, 8.935 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.83     | 110.83     | 110.83     |   0.0 | 99.03
Neigh   | 0.57095    | 0.57095    | 0.57095    |   0.0 |  0.51
Comm    | 0.098214   | 0.098214   | 0.098214   |   0.0 |  0.09
Output  | 0.00021181 | 0.00021181 | 0.00021181 |   0.0 |  0.00
Modify  | 0.36534    | 0.36534    | 0.36534    |   0.0 |  0.33
Other   |            | 0.05653    |            |       |  0.05

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

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

Performance: 0.729 ns/day, 32.904 hours/ns, 8.442 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.29     | 117.29     | 117.29     |   0.0 | 99.01
Neigh   | 0.5904     | 0.5904     | 0.5904     |   0.0 |  0.50
Comm    | 0.10622    | 0.10622    | 0.10622    |   0.0 |  0.09
Output  | 0.00025205 | 0.00025205 | 0.00025205 |   0.0 |  0.00
Modify  | 0.41289    | 0.41289    | 0.41289    |   0.0 |  0.35
Other   |            | 0.05932    |            |       |  0.05

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

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

Performance: 0.693 ns/day, 34.654 hours/ns, 8.016 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.5      | 123.5      | 123.5      |   0.0 | 99.00
Neigh   | 0.62092    | 0.62092    | 0.62092    |   0.0 |  0.50
Comm    | 0.11186    | 0.11186    | 0.11186    |   0.0 |  0.09
Output  | 0.00016862 | 0.00016862 | 0.00016862 |   0.0 |  0.00
Modify  | 0.45774    | 0.45774    | 0.45774    |   0.0 |  0.37
Other   |            | 0.06232    |            |       |  0.05

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

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

Performance: 0.760 ns/day, 31.596 hours/ns, 8.791 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.63     | 112.63     | 112.63     |   0.0 | 99.02
Neigh   | 0.57713    | 0.57713    | 0.57713    |   0.0 |  0.51
Comm    | 0.10077    | 0.10077    | 0.10077    |   0.0 |  0.09
Output  | 0.00016953 | 0.00016953 | 0.00016953 |   0.0 |  0.00
Modify  | 0.37935    | 0.37935    | 0.37935    |   0.0 |  0.33
Other   |            | 0.05836    |            |       |  0.05

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

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

Performance: 0.780 ns/day, 30.761 hours/ns, 9.030 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.66     | 109.66     | 109.66     |   0.0 | 99.02
Neigh   | 0.56885    | 0.56885    | 0.56885    |   0.0 |  0.51
Comm    | 0.097682   | 0.097682   | 0.097682   |   0.0 |  0.09
Output  | 0.00016829 | 0.00016829 | 0.00016829 |   0.0 |  0.00
Modify  | 0.3562     | 0.3562     | 0.3562     |   0.0 |  0.32
Other   |            | 0.0572     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3844 ave        3844 max        3844 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127200 ave      127200 max      127200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.751 ns/day, 31.946 hours/ns, 8.695 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.87     | 113.87     | 113.87     |   0.0 | 99.02
Neigh   | 0.58154    | 0.58154    | 0.58154    |   0.0 |  0.51
Comm    | 0.10207    | 0.10207    | 0.10207    |   0.0 |  0.09
Output  | 0.0001699  | 0.0001699  | 0.0001699  |   0.0 |  0.00
Modify  | 0.38704    | 0.38704    | 0.38704    |   0.0 |  0.34
Other   |            | 0.05891    |            |       |  0.05

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

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

Performance: 0.704 ns/day, 34.073 hours/ns, 8.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    | 121.43     | 121.43     | 121.43     |   0.0 | 99.00
Neigh   | 0.61315    | 0.61315    | 0.61315    |   0.0 |  0.50
Comm    | 0.11004    | 0.11004    | 0.11004    |   0.0 |  0.09
Output  | 0.00020555 | 0.00020555 | 0.00020555 |   0.0 |  0.00
Modify  | 0.44524    | 0.44524    | 0.44524    |   0.0 |  0.36
Other   |            | 0.06233    |            |       |  0.05

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

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

Performance: 0.694 ns/day, 34.583 hours/ns, 8.032 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.28     | 123.28     | 123.28     |   0.0 | 99.02
Neigh   | 0.59509    | 0.59509    | 0.59509    |   0.0 |  0.48
Comm    | 0.10976    | 0.10976    | 0.10976    |   0.0 |  0.09
Output  | 0.00026153 | 0.00026153 | 0.00026153 |   0.0 |  0.00
Modify  | 0.45067    | 0.45067    | 0.45067    |   0.0 |  0.36
Other   |            | 0.06252    |            |       |  0.05

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

Total # of neighbors = 127448
Ave neighs/atom = 63.724
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.409913619028, Press = -0.306962726217997
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    134000  -3632.097      -3632.097      -3713.7443     -3713.7443      315.98356      315.98356      41993.235      41993.235      77.246784      77.246784    
    135000  -3634.212      -3634.212      -3716.0259     -3716.0259      316.62822      316.62822      41810.291      41810.291      629.95612      629.95612    
Loop time of 124.55 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.694 ns/day, 34.597 hours/ns, 8.029 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.31     | 123.31     | 123.31     |   0.0 | 99.00
Neigh   | 0.61955    | 0.61955    | 0.61955    |   0.0 |  0.50
Comm    | 0.11222    | 0.11222    | 0.11222    |   0.0 |  0.09
Output  | 0.00024843 | 0.00024843 | 0.00024843 |   0.0 |  0.00
Modify  | 0.45009    | 0.45009    | 0.45009    |   0.0 |  0.36
Other   |            | 0.06272    |            |       |  0.05

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

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

Performance: 0.694 ns/day, 34.588 hours/ns, 8.031 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.28     | 123.28     | 123.28     |   0.0 | 99.01
Neigh   | 0.61431    | 0.61431    | 0.61431    |   0.0 |  0.49
Comm    | 0.11077    | 0.11077    | 0.11077    |   0.0 |  0.09
Output  | 0.00016963 | 0.00016963 | 0.00016963 |   0.0 |  0.00
Modify  | 0.44749    | 0.44749    | 0.44749    |   0.0 |  0.36
Other   |            | 0.06249    |            |       |  0.05

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

Total # of neighbors = 127444
Ave neighs/atom = 63.722
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.39207479158, Press = 0.127414718858158
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    136000  -3636.6171     -3636.6171     -3713.9619     -3713.9619      299.33222      299.33222      42018.513      42018.513     -66.863553     -66.863553    
    137000  -3635.1129     -3635.1129     -3715.541      -3715.541       311.265        311.265        42168.16       42168.16      -551.29868     -551.29868    
Loop time of 124.22 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.696 ns/day, 34.505 hours/ns, 8.050 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.98     | 122.98     | 122.98     |   0.0 | 99.00
Neigh   | 0.6152     | 0.6152     | 0.6152     |   0.0 |  0.50
Comm    | 0.11252    | 0.11252    | 0.11252    |   0.0 |  0.09
Output  | 0.00020863 | 0.00020863 | 0.00020863 |   0.0 |  0.00
Modify  | 0.45272    | 0.45272    | 0.45272    |   0.0 |  0.36
Other   |            | 0.06294    |            |       |  0.05

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

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

Performance: 0.774 ns/day, 30.989 hours/ns, 8.964 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.49     | 110.49     | 110.49     |   0.0 | 99.05
Neigh   | 0.54674    | 0.54674    | 0.54674    |   0.0 |  0.49
Comm    | 0.097471   | 0.097471   | 0.097471   |   0.0 |  0.09
Output  | 0.00016899 | 0.00016899 | 0.00016899 |   0.0 |  0.00
Modify  | 0.36292    | 0.36292    | 0.36292    |   0.0 |  0.33
Other   |            | 0.05742    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3808 ave        3808 max        3808 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126942 ave      126942 max      126942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126942
Ave neighs/atom = 63.471
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.370078631691, Press = -0.411414734415638
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    138000  -3631.7563     -3631.7563     -3714.551      -3714.551       320.42404      320.42404      42081.392      42081.392     -152.88577     -152.88577    
    139000  -3633.9145     -3633.9145     -3714.0471     -3714.0471      310.12151      310.12151      41956.651      41956.651      129.40369      129.40369    
Loop time of 110.216 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.15     | 109.15     | 109.15     |   0.0 | 99.03
Neigh   | 0.56493    | 0.56493    | 0.56493    |   0.0 |  0.51
Comm    | 0.095785   | 0.095785   | 0.095785   |   0.0 |  0.09
Output  | 0.00016891 | 0.00016891 | 0.00016891 |   0.0 |  0.00
Modify  | 0.35373    | 0.35373    | 0.35373    |   0.0 |  0.32
Other   |            | 0.05612    |            |       |  0.05

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

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

Performance: 0.782 ns/day, 30.682 hours/ns, 9.053 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.38     | 109.38     | 109.38     |   0.0 | 99.03
Neigh   | 0.56826    | 0.56826    | 0.56826    |   0.0 |  0.51
Comm    | 0.096439   | 0.096439   | 0.096439   |   0.0 |  0.09
Output  | 0.00020615 | 0.00020615 | 0.00020615 |   0.0 |  0.00
Modify  | 0.35458    | 0.35458    | 0.35458    |   0.0 |  0.32
Other   |            | 0.05676    |            |       |  0.05

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

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

Performance: 0.779 ns/day, 30.819 hours/ns, 9.013 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.86     | 109.86     | 109.86     |   0.0 | 99.02
Neigh   | 0.57145    | 0.57145    | 0.57145    |   0.0 |  0.52
Comm    | 0.098406   | 0.098406   | 0.098406   |   0.0 |  0.09
Output  | 0.00016869 | 0.00016869 | 0.00016869 |   0.0 |  0.00
Modify  | 0.35924    | 0.35924    | 0.35924    |   0.0 |  0.32
Other   |            | 0.05846    |            |       |  0.05

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

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

Performance: 0.779 ns/day, 30.793 hours/ns, 9.021 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.8      | 109.8      | 109.8      |   0.0 | 99.04
Neigh   | 0.54731    | 0.54731    | 0.54731    |   0.0 |  0.49
Comm    | 0.098025   | 0.098025   | 0.098025   |   0.0 |  0.09
Output  | 0.00017053 | 0.00017053 | 0.00017053 |   0.0 |  0.00
Modify  | 0.35717    | 0.35717    | 0.35717    |   0.0 |  0.32
Other   |            | 0.05773    |            |       |  0.05

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

Total # of neighbors = 127058
Ave neighs/atom = 63.529
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.35581179128, Press = -0.195095120155893
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    142000  -3631.0396     -3631.0396     -3713.7334     -3713.7334      320.03362      320.03362      42156.99       42156.99      -228.63466     -228.63466    
    143000  -3633.7903     -3633.7903     -3715.4994     -3715.4994      316.22261      316.22261      41899.354      41899.354      308.62579      308.62579    
Loop time of 110.819 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.780 ns/day, 30.783 hours/ns, 9.024 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.73     | 109.73     | 109.73     |   0.0 | 99.02
Neigh   | 0.57089    | 0.57089    | 0.57089    |   0.0 |  0.52
Comm    | 0.097426   | 0.097426   | 0.097426   |   0.0 |  0.09
Output  | 0.00021079 | 0.00021079 | 0.00021079 |   0.0 |  0.00
Modify  | 0.35892    | 0.35892    | 0.35892    |   0.0 |  0.32
Other   |            | 0.05745    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.64     | 118.64     | 118.64     |   0.0 | 99.01
Neigh   | 0.59979    | 0.59979    | 0.59979    |   0.0 |  0.50
Comm    | 0.10723    | 0.10723    | 0.10723    |   0.0 |  0.09
Output  | 0.00020558 | 0.00020558 | 0.00020558 |   0.0 |  0.00
Modify  | 0.42169    | 0.42169    | 0.42169    |   0.0 |  0.35
Other   |            | 0.06149    |            |       |  0.05

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

Total # of neighbors = 127454
Ave neighs/atom = 63.727
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.381579594263, Press = -0.195028100480805
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    144000  -3627.5396     -3627.5396     -3710.833      -3710.833       322.35438      322.35438      42007.644      42007.644      227.80623      227.80623    
    145000  -3634.5672     -3634.5672     -3715.2997     -3715.2997      312.44307      312.44307      42071.598      42071.598     -298.11141     -298.11141    
Loop time of 124.831 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.692 ns/day, 34.675 hours/ns, 8.011 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.62     | 123.62     | 123.62     |   0.0 | 99.03
Neigh   | 0.58787    | 0.58787    | 0.58787    |   0.0 |  0.47
Comm    | 0.11144    | 0.11144    | 0.11144    |   0.0 |  0.09
Output  | 0.00025463 | 0.00025463 | 0.00025463 |   0.0 |  0.00
Modify  | 0.45478    | 0.45478    | 0.45478    |   0.0 |  0.36
Other   |            | 0.06203    |            |       |  0.05

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

Total # of neighbors = 127280
Ave neighs/atom = 63.64
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.396832102935, Press = -0.0466145857237831
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    145000  -3634.5672     -3634.5672     -3715.2997     -3715.2997      312.44307      312.44307      42071.598      42071.598     -298.11141     -298.11141    
    146000  -3633.9144     -3633.9144     -3715.05       -3715.05        314.00325      314.00325      42357.224      42357.224     -1012.0658     -1012.0658    
Loop time of 122.548 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.705 ns/day, 34.041 hours/ns, 8.160 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.33     | 121.33     | 121.33     |   0.0 | 99.00
Neigh   | 0.60981    | 0.60981    | 0.60981    |   0.0 |  0.50
Comm    | 0.10896    | 0.10896    | 0.10896    |   0.0 |  0.09
Output  | 0.0002588  | 0.0002588  | 0.0002588  |   0.0 |  0.00
Modify  | 0.44091    | 0.44091    | 0.44091    |   0.0 |  0.36
Other   |            | 0.06186    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.34     | 122.34     | 122.34     |   0.0 | 98.98
Neigh   | 0.64401    | 0.64401    | 0.64401    |   0.0 |  0.52
Comm    | 0.11042    | 0.11042    | 0.11042    |   0.0 |  0.09
Output  | 0.00020725 | 0.00020725 | 0.00020725 |   0.0 |  0.00
Modify  | 0.44911    | 0.44911    | 0.44911    |   0.0 |  0.36
Other   |            | 0.06179    |            |       |  0.05

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

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

Performance: 0.779 ns/day, 30.790 hours/ns, 9.022 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.76     | 109.76     | 109.76     |   0.0 | 99.03
Neigh   | 0.57018    | 0.57018    | 0.57018    |   0.0 |  0.51
Comm    | 0.097407   | 0.097407   | 0.097407   |   0.0 |  0.09
Output  | 0.00016868 | 0.00016868 | 0.00016868 |   0.0 |  0.00
Modify  | 0.35764    | 0.35764    | 0.35764    |   0.0 |  0.32
Other   |            | 0.05505    |            |       |  0.05

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

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

Performance: 0.780 ns/day, 30.784 hours/ns, 9.023 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.74     | 109.74     | 109.74     |   0.0 | 99.03
Neigh   | 0.56948    | 0.56948    | 0.56948    |   0.0 |  0.51
Comm    | 0.097811   | 0.097811   | 0.097811   |   0.0 |  0.09
Output  | 0.00016953 | 0.00016953 | 0.00016953 |   0.0 |  0.00
Modify  | 0.35656    | 0.35656    | 0.35656    |   0.0 |  0.32
Other   |            | 0.05535    |            |       |  0.05

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

Total # of neighbors = 127124
Ave neighs/atom = 63.562
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.384714277648, Press = -0.25675437471752
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    149000  -3634.7939     -3634.7939     -3716.8148     -3716.8148      317.42951      317.42951      42023.423      42023.423     -52.060401     -52.060401    
    150000  -3631.4808     -3631.4808     -3713.1833     -3713.1833      316.19692      316.19692      41947.707      41947.707      285.13189      285.13189    
Loop time of 112.591 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.51     | 111.51     | 111.51     |   0.0 | 99.04
Neigh   | 0.55113    | 0.55113    | 0.55113    |   0.0 |  0.49
Comm    | 0.098096   | 0.098096   | 0.098096   |   0.0 |  0.09
Output  | 0.00020665 | 0.00020665 | 0.00020665 |   0.0 |  0.00
Modify  | 0.37129    | 0.37129    | 0.37129    |   0.0 |  0.33
Other   |            | 0.05701    |            |       |  0.05

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

Total # of neighbors = 127380
Ave neighs/atom = 63.69
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.380596297013, Press = -0.300475038493149
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    150000  -3631.4808     -3631.4808     -3713.1833     -3713.1833      316.19692      316.19692      41947.707      41947.707      285.13189      285.13189    
    151000  -3631.2332     -3631.2332     -3712.3629     -3712.3629      313.9801       313.9801       41955.574      41955.574      304.32888      304.32888    
Loop time of 110.381 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.28     | 109.28     | 109.28     |   0.0 | 99.00
Neigh   | 0.59116    | 0.59116    | 0.59116    |   0.0 |  0.54
Comm    | 0.096709   | 0.096709   | 0.096709   |   0.0 |  0.09
Output  | 0.00017085 | 0.00017085 | 0.00017085 |   0.0 |  0.00
Modify  | 0.35486    | 0.35486    | 0.35486    |   0.0 |  0.32
Other   |            | 0.05865    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.3      | 109.3      | 109.3      |   0.0 | 99.03
Neigh   | 0.56525    | 0.56525    | 0.56525    |   0.0 |  0.51
Comm    | 0.096271   | 0.096271   | 0.096271   |   0.0 |  0.09
Output  | 0.00016907 | 0.00016907 | 0.00016907 |   0.0 |  0.00
Modify  | 0.35593    | 0.35593    | 0.35593    |   0.0 |  0.32
Other   |            | 0.05813    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.2      | 109.2      | 109.2      |   0.0 | 99.02
Neigh   | 0.56625    | 0.56625    | 0.56625    |   0.0 |  0.51
Comm    | 0.096222   | 0.096222   | 0.096222   |   0.0 |  0.09
Output  | 0.0002153  | 0.0002153  | 0.0002153  |   0.0 |  0.00
Modify  | 0.35638    | 0.35638    | 0.35638    |   0.0 |  0.32
Other   |            | 0.05865    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.11     | 109.11     | 109.11     |   0.0 | 99.02
Neigh   | 0.56643    | 0.56643    | 0.56643    |   0.0 |  0.51
Comm    | 0.09678    | 0.09678    | 0.09678    |   0.0 |  0.09
Output  | 0.00017144 | 0.00017144 | 0.00017144 |   0.0 |  0.00
Modify  | 0.35606    | 0.35606    | 0.35606    |   0.0 |  0.32
Other   |            | 0.05875    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3845 ave        3845 max        3845 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127130 ave      127130 max      127130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.781 ns/day, 30.719 hours/ns, 9.042 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.51     | 109.51     | 109.51     |   0.0 | 99.03
Neigh   | 0.56678    | 0.56678    | 0.56678    |   0.0 |  0.51
Comm    | 0.096722   | 0.096722   | 0.096722   |   0.0 |  0.09
Output  | 0.00021799 | 0.00021799 | 0.00021799 |   0.0 |  0.00
Modify  | 0.35594    | 0.35594    | 0.35594    |   0.0 |  0.32
Other   |            | 0.05848    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.29     | 109.29     | 109.29     |   0.0 | 99.02
Neigh   | 0.56689    | 0.56689    | 0.56689    |   0.0 |  0.51
Comm    | 0.096441   | 0.096441   | 0.096441   |   0.0 |  0.09
Output  | 0.00016946 | 0.00016946 | 0.00016946 |   0.0 |  0.00
Modify  | 0.35633    | 0.35633    | 0.35633    |   0.0 |  0.32
Other   |            | 0.05809    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.11     | 109.11     | 109.11     |   0.0 | 99.02
Neigh   | 0.56677    | 0.56677    | 0.56677    |   0.0 |  0.51
Comm    | 0.096565   | 0.096565   | 0.096565   |   0.0 |  0.09
Output  | 0.00017025 | 0.00017025 | 0.00017025 |   0.0 |  0.00
Modify  | 0.357      | 0.357      | 0.357      |   0.0 |  0.32
Other   |            | 0.05839    |            |       |  0.05

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

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

Performance: 0.782 ns/day, 30.683 hours/ns, 9.053 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.38     | 109.38     | 109.38     |   0.0 | 99.02
Neigh   | 0.5666     | 0.5666     | 0.5666     |   0.0 |  0.51
Comm    | 0.096106   | 0.096106   | 0.096106   |   0.0 |  0.09
Output  | 0.00017057 | 0.00017057 | 0.00017057 |   0.0 |  0.00
Modify  | 0.35802    | 0.35802    | 0.35802    |   0.0 |  0.32
Other   |            | 0.05852    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.23     | 109.23     | 109.23     |   0.0 | 99.02
Neigh   | 0.56608    | 0.56608    | 0.56608    |   0.0 |  0.51
Comm    | 0.09618    | 0.09618    | 0.09618    |   0.0 |  0.09
Output  | 0.00021196 | 0.00021196 | 0.00021196 |   0.0 |  0.00
Modify  | 0.3559     | 0.3559     | 0.3559     |   0.0 |  0.32
Other   |            | 0.05935    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.25     | 109.25     | 109.25     |   0.0 | 99.02
Neigh   | 0.56604    | 0.56604    | 0.56604    |   0.0 |  0.51
Comm    | 0.096377   | 0.096377   | 0.096377   |   0.0 |  0.09
Output  | 0.00016973 | 0.00016973 | 0.00016973 |   0.0 |  0.00
Modify  | 0.35718    | 0.35718    | 0.35718    |   0.0 |  0.32
Other   |            | 0.05868    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.17     | 109.17     | 109.17     |   0.0 | 99.04
Neigh   | 0.54201    | 0.54201    | 0.54201    |   0.0 |  0.49
Comm    | 0.096312   | 0.096312   | 0.096312   |   0.0 |  0.09
Output  | 0.00016877 | 0.00016877 | 0.00016877 |   0.0 |  0.00
Modify  | 0.35594    | 0.35594    | 0.35594    |   0.0 |  0.32
Other   |            | 0.05853    |            |       |  0.05

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

Total # of neighbors = 127200
Ave neighs/atom = 63.6
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.386720296669, Press = -0.341760814364929
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    161000  -3634.0115     -3634.0115     -3714.0549     -3714.0549      309.7764       309.7764       42061.926      42061.926     -177.8586      -177.8586     
    162000  -3630.775      -3630.775      -3713.7866     -3713.7866      321.26351      321.26351      41900.692      41900.692      496.11516      496.11516    
Loop time of 110.161 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.08     | 109.08     | 109.08     |   0.0 | 99.02
Neigh   | 0.56701    | 0.56701    | 0.56701    |   0.0 |  0.51
Comm    | 0.096931   | 0.096931   | 0.096931   |   0.0 |  0.09
Output  | 0.00016958 | 0.00016958 | 0.00016958 |   0.0 |  0.00
Modify  | 0.35582    | 0.35582    | 0.35582    |   0.0 |  0.32
Other   |            | 0.05834    |            |       |  0.05

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

Total # of neighbors = 127428
Ave neighs/atom = 63.714
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.392041584531, Press = -0.367331446632248
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    162000  -3630.775      -3630.775      -3713.7866     -3713.7866      321.26351      321.26351      41900.692      41900.692      496.11516      496.11516    
    163000  -3629.9775     -3629.9775     -3712.6959     -3712.6959      320.12885      320.12885      41977.696      41977.696      188.65436      188.65436    
Loop time of 110.351 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.27     | 109.27     | 109.27     |   0.0 | 99.02
Neigh   | 0.56643    | 0.56643    | 0.56643    |   0.0 |  0.51
Comm    | 0.096182   | 0.096182   | 0.096182   |   0.0 |  0.09
Output  | 0.00021097 | 0.00021097 | 0.00021097 |   0.0 |  0.00
Modify  | 0.35673    | 0.35673    | 0.35673    |   0.0 |  0.32
Other   |            | 0.05908    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.27     | 109.27     | 109.27     |   0.0 | 99.02
Neigh   | 0.56667    | 0.56667    | 0.56667    |   0.0 |  0.51
Comm    | 0.097059   | 0.097059   | 0.097059   |   0.0 |  0.09
Output  | 0.00017005 | 0.00017005 | 0.00017005 |   0.0 |  0.00
Modify  | 0.35743    | 0.35743    | 0.35743    |   0.0 |  0.32
Other   |            | 0.05882    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3803 ave        3803 max        3803 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126896 ave      126896 max      126896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126896
Ave neighs/atom = 63.448
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.400640515267, Press = 0.0101061205158529
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    164000  -3632.4499     -3632.4499     -3714.5682     -3714.5682      317.80626      317.80626      42147.714      42147.714     -285.0773      -285.0773     
    165000  -3632.7154     -3632.7154     -3714.2022     -3714.2022      315.36209      315.36209      42090.607      42090.607     -246.57595     -246.57595    
Loop time of 110.101 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.05     | 109.05     | 109.05     |   0.0 | 99.04
Neigh   | 0.54217    | 0.54217    | 0.54217    |   0.0 |  0.49
Comm    | 0.096382   | 0.096382   | 0.096382   |   0.0 |  0.09
Output  | 0.00016993 | 0.00016993 | 0.00016993 |   0.0 |  0.00
Modify  | 0.35647    | 0.35647    | 0.35647    |   0.0 |  0.32
Other   |            | 0.05884    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3801 ave        3801 max        3801 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127134 ave      127134 max      127134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127134
Ave neighs/atom = 63.567
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.416113861927, Press = -0.241879179195891
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    165000  -3632.7154     -3632.7154     -3714.2022     -3714.2022      315.36209      315.36209      42090.607      42090.607     -246.57595     -246.57595    
    166000  -3633.883      -3633.883      -3715.9288     -3715.9288      317.52566      317.52566      42059.779      42059.779     -191.72399     -191.72399    
Loop time of 110.335 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.783 ns/day, 30.648 hours/ns, 9.063 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.28     | 109.28     | 109.28     |   0.0 | 99.04
Neigh   | 0.54273    | 0.54273    | 0.54273    |   0.0 |  0.49
Comm    | 0.095628   | 0.095628   | 0.095628   |   0.0 |  0.09
Output  | 0.00021987 | 0.00021987 | 0.00021987 |   0.0 |  0.00
Modify  | 0.3576     | 0.3576     | 0.3576     |   0.0 |  0.32
Other   |            | 0.05839    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3844 ave        3844 max        3844 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       126962 ave      126962 max      126962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126962
Ave neighs/atom = 63.481
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.421142931582, Press = -0.24958103655666
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    166000  -3633.883      -3633.883      -3715.9288     -3715.9288      317.52566      317.52566      42059.779      42059.779     -191.72399     -191.72399    
    167000  -3632.1412     -3632.1412     -3714.2236     -3714.2236      317.66748      317.66748      41978.291      41978.291      57.244118      57.244118    
Loop time of 110.261 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.18     | 109.18     | 109.18     |   0.0 | 99.02
Neigh   | 0.56593    | 0.56593    | 0.56593    |   0.0 |  0.51
Comm    | 0.09673    | 0.09673    | 0.09673    |   0.0 |  0.09
Output  | 0.00021799 | 0.00021799 | 0.00021799 |   0.0 |  0.00
Modify  | 0.3564     | 0.3564     | 0.3564     |   0.0 |  0.32
Other   |            | 0.0587     |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.26     | 109.26     | 109.26     |   0.0 | 99.02
Neigh   | 0.56649    | 0.56649    | 0.56649    |   0.0 |  0.51
Comm    | 0.096438   | 0.096438   | 0.096438   |   0.0 |  0.09
Output  | 0.00016986 | 0.00016986 | 0.00016986 |   0.0 |  0.00
Modify  | 0.35693    | 0.35693    | 0.35693    |   0.0 |  0.32
Other   |            | 0.05843    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.17     | 109.17     | 109.17     |   0.0 | 99.02
Neigh   | 0.56674    | 0.56674    | 0.56674    |   0.0 |  0.51
Comm    | 0.095642   | 0.095642   | 0.095642   |   0.0 |  0.09
Output  | 0.00016972 | 0.00016972 | 0.00016972 |   0.0 |  0.00
Modify  | 0.35653    | 0.35653    | 0.35653    |   0.0 |  0.32
Other   |            | 0.05857    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.24     | 109.24     | 109.24     |   0.0 | 99.04
Neigh   | 0.54239    | 0.54239    | 0.54239    |   0.0 |  0.49
Comm    | 0.095807   | 0.095807   | 0.095807   |   0.0 |  0.09
Output  | 0.00017073 | 0.00017073 | 0.00017073 |   0.0 |  0.00
Modify  | 0.35648    | 0.35648    | 0.35648    |   0.0 |  0.32
Other   |            | 0.05916    |            |       |  0.05

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

Total # of neighbors = 127264
Ave neighs/atom = 63.632
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.440619135756, Press = -0.224158283632028
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    170000  -3631.697      -3631.697      -3712.5711     -3712.5711      312.99101      312.99101      42056.097      42056.097     -33.638069     -33.638069    
    171000  -3632.4299     -3632.4299     -3711.0779     -3711.0779      304.37612      304.37612      41960.91       41960.91       296.07157      296.07157    
Loop time of 110.286 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.23     | 109.23     | 109.23     |   0.0 | 99.04
Neigh   | 0.54269    | 0.54269    | 0.54269    |   0.0 |  0.49
Comm    | 0.096128   | 0.096128   | 0.096128   |   0.0 |  0.09
Output  | 0.0002179  | 0.0002179  | 0.0002179  |   0.0 |  0.00
Modify  | 0.35737    | 0.35737    | 0.35737    |   0.0 |  0.32
Other   |            | 0.0583     |            |       |  0.05

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

Total # of neighbors = 127488
Ave neighs/atom = 63.744
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.447675190311, Press = -0.274418167170385
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    171000  -3632.4299     -3632.4299     -3711.0779     -3711.0779      304.37612      304.37612      41960.91       41960.91       296.07157      296.07157    
    172000  -3627.8334     -3627.8334     -3710.9404     -3710.9404      321.63262      321.63262      42244.009      42244.009     -556.74011     -556.74011    
Loop time of 110.371 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.29     | 109.29     | 109.29     |   0.0 | 99.02
Neigh   | 0.5661     | 0.5661     | 0.5661     |   0.0 |  0.51
Comm    | 0.096285   | 0.096285   | 0.096285   |   0.0 |  0.09
Output  | 0.00016946 | 0.00016946 | 0.00016946 |   0.0 |  0.00
Modify  | 0.35773    | 0.35773    | 0.35773    |   0.0 |  0.32
Other   |            | 0.05876    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3704 ave        3704 max        3704 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127238 ave      127238 max      127238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.1      | 109.1      | 109.1      |   0.0 | 99.02
Neigh   | 0.56701    | 0.56701    | 0.56701    |   0.0 |  0.51
Comm    | 0.097024   | 0.097024   | 0.097024   |   0.0 |  0.09
Output  | 0.00016948 | 0.00016948 | 0.00016948 |   0.0 |  0.00
Modify  | 0.35732    | 0.35732    | 0.35732    |   0.0 |  0.32
Other   |            | 0.05804    |            |       |  0.05

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

Total # of neighbors = 126860
Ave neighs/atom = 63.43
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.462870589868, Press = -0.483100422713555
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    173000  -3633.834      -3633.834      -3715.2653     -3715.2653      315.14728      315.14728      42147.011      42147.011     -499.21023     -499.21023    
    174000  -3629.7238     -3629.7238     -3711.6094     -3711.6094      316.90573      316.90573      41993.707      41993.707      133.16215      133.16215    
Loop time of 110.31 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.23     | 109.23     | 109.23     |   0.0 | 99.02
Neigh   | 0.56538    | 0.56538    | 0.56538    |   0.0 |  0.51
Comm    | 0.096437   | 0.096437   | 0.096437   |   0.0 |  0.09
Output  | 0.00020937 | 0.00020937 | 0.00020937 |   0.0 |  0.00
Modify  | 0.35615    | 0.35615    | 0.35615    |   0.0 |  0.32
Other   |            | 0.05891    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.17     | 109.17     | 109.17     |   0.0 | 99.00
Neigh   | 0.59229    | 0.59229    | 0.59229    |   0.0 |  0.54
Comm    | 0.097469   | 0.097469   | 0.097469   |   0.0 |  0.09
Output  | 0.00017058 | 0.00017058 | 0.00017058 |   0.0 |  0.00
Modify  | 0.35695    | 0.35695    | 0.35695    |   0.0 |  0.32
Other   |            | 0.05825    |            |       |  0.05

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

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

Performance: 0.782 ns/day, 30.687 hours/ns, 9.052 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.4      | 109.4      | 109.4      |   0.0 | 99.02
Neigh   | 0.56636    | 0.56636    | 0.56636    |   0.0 |  0.51
Comm    | 0.095565   | 0.095565   | 0.095565   |   0.0 |  0.09
Output  | 0.00017067 | 0.00017067 | 0.00017067 |   0.0 |  0.00
Modify  | 0.35724    | 0.35724    | 0.35724    |   0.0 |  0.32
Other   |            | 0.05813    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.02     | 109.02     | 109.02     |   0.0 | 99.02
Neigh   | 0.56516    | 0.56516    | 0.56516    |   0.0 |  0.51
Comm    | 0.095953   | 0.095953   | 0.095953   |   0.0 |  0.09
Output  | 0.00016976 | 0.00016976 | 0.00016976 |   0.0 |  0.00
Modify  | 0.35756    | 0.35756    | 0.35756    |   0.0 |  0.32
Other   |            | 0.05902    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.04     | 109.04     | 109.04     |   0.0 | 99.02
Neigh   | 0.56676    | 0.56676    | 0.56676    |   0.0 |  0.51
Comm    | 0.096023   | 0.096023   | 0.096023   |   0.0 |  0.09
Output  | 0.00016972 | 0.00016972 | 0.00016972 |   0.0 |  0.00
Modify  | 0.35777    | 0.35777    | 0.35777    |   0.0 |  0.32
Other   |            | 0.05835    |            |       |  0.05

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

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

Performance: 0.782 ns/day, 30.693 hours/ns, 9.050 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.42     | 109.42     | 109.42     |   0.0 | 99.02
Neigh   | 0.56722    | 0.56722    | 0.56722    |   0.0 |  0.51
Comm    | 0.096291   | 0.096291   | 0.096291   |   0.0 |  0.09
Output  | 0.00049976 | 0.00049976 | 0.00049976 |   0.0 |  0.00
Modify  | 0.35641    | 0.35641    | 0.35641    |   0.0 |  0.32
Other   |            | 0.05843    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.14     | 109.14     | 109.14     |   0.0 | 99.00
Neigh   | 0.59161    | 0.59161    | 0.59161    |   0.0 |  0.54
Comm    | 0.095895   | 0.095895   | 0.095895   |   0.0 |  0.09
Output  | 0.00016943 | 0.00016943 | 0.00016943 |   0.0 |  0.00
Modify  | 0.35684    | 0.35684    | 0.35684    |   0.0 |  0.32
Other   |            | 0.05855    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.28     | 109.28     | 109.28     |   0.0 | 99.03
Neigh   | 0.56451    | 0.56451    | 0.56451    |   0.0 |  0.51
Comm    | 0.096236   | 0.096236   | 0.096236   |   0.0 |  0.09
Output  | 0.00017157 | 0.00017157 | 0.00017157 |   0.0 |  0.00
Modify  | 0.35626    | 0.35626    | 0.35626    |   0.0 |  0.32
Other   |            | 0.05827    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.3      | 109.3      | 109.3      |   0.0 | 99.02
Neigh   | 0.56586    | 0.56586    | 0.56586    |   0.0 |  0.51
Comm    | 0.096305   | 0.096305   | 0.096305   |   0.0 |  0.09
Output  | 0.00016883 | 0.00016883 | 0.00016883 |   0.0 |  0.00
Modify  | 0.3566     | 0.3566     | 0.3566     |   0.0 |  0.32
Other   |            | 0.05812    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.22     | 109.22     | 109.22     |   0.0 | 99.02
Neigh   | 0.56598    | 0.56598    | 0.56598    |   0.0 |  0.51
Comm    | 0.096457   | 0.096457   | 0.096457   |   0.0 |  0.09
Output  | 0.00017084 | 0.00017084 | 0.00017084 |   0.0 |  0.00
Modify  | 0.3578     | 0.3578     | 0.3578     |   0.0 |  0.32
Other   |            | 0.05874    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.25     | 109.25     | 109.25     |   0.0 | 99.02
Neigh   | 0.566      | 0.566      | 0.566      |   0.0 |  0.51
Comm    | 0.09645    | 0.09645    | 0.09645    |   0.0 |  0.09
Output  | 0.0002118  | 0.0002118  | 0.0002118  |   0.0 |  0.00
Modify  | 0.35613    | 0.35613    | 0.35613    |   0.0 |  0.32
Other   |            | 0.05856    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.17     | 109.17     | 109.17     |   0.0 | 99.02
Neigh   | 0.56667    | 0.56667    | 0.56667    |   0.0 |  0.51
Comm    | 0.09629    | 0.09629    | 0.09629    |   0.0 |  0.09
Output  | 0.00017082 | 0.00017082 | 0.00017082 |   0.0 |  0.00
Modify  | 0.35589    | 0.35589    | 0.35589    |   0.0 |  0.32
Other   |            | 0.05857    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.09     | 109.09     | 109.09     |   0.0 | 99.02
Neigh   | 0.56614    | 0.56614    | 0.56614    |   0.0 |  0.51
Comm    | 0.097148   | 0.097148   | 0.097148   |   0.0 |  0.09
Output  | 0.00021801 | 0.00021801 | 0.00021801 |   0.0 |  0.00
Modify  | 0.35621    | 0.35621    | 0.35621    |   0.0 |  0.32
Other   |            | 0.05853    |            |       |  0.05

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

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

Performance: 0.781 ns/day, 30.725 hours/ns, 9.041 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.53     | 109.53     | 109.53     |   0.0 | 99.03
Neigh   | 0.56547    | 0.56547    | 0.56547    |   0.0 |  0.51
Comm    | 0.096566   | 0.096566   | 0.096566   |   0.0 |  0.09
Output  | 0.00016926 | 0.00016926 | 0.00016926 |   0.0 |  0.00
Modify  | 0.35709    | 0.35709    | 0.35709    |   0.0 |  0.32
Other   |            | 0.05871    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3803 ave        3803 max        3803 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127362 ave      127362 max      127362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.2      | 109.2      | 109.2      |   0.0 | 99.02
Neigh   | 0.56642    | 0.56642    | 0.56642    |   0.0 |  0.51
Comm    | 0.096777   | 0.096777   | 0.096777   |   0.0 |  0.09
Output  | 0.00016928 | 0.00016928 | 0.00016928 |   0.0 |  0.00
Modify  | 0.35577    | 0.35577    | 0.35577    |   0.0 |  0.32
Other   |            | 0.05897    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.15     | 109.15     | 109.15     |   0.0 | 99.05
Neigh   | 0.54175    | 0.54175    | 0.54175    |   0.0 |  0.49
Comm    | 0.096169   | 0.096169   | 0.096169   |   0.0 |  0.09
Output  | 0.00017058 | 0.00017058 | 0.00017058 |   0.0 |  0.00
Modify  | 0.35614    | 0.35614    | 0.35614    |   0.0 |  0.32
Other   |            | 0.05809    |            |       |  0.05

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

Total # of neighbors = 127362
Ave neighs/atom = 63.681
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.500285042726, Press = -0.107963504934225
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    189000  -3630.8335     -3630.8335     -3715.0616     -3715.0616      325.97154      325.97154      42069.514      42069.514     -249.15933     -249.15933    
    190000  -3634.5856     -3634.5856     -3714.7151     -3714.7151      310.10921      310.10921      41991.551      41991.551     -18.59732      -18.59732     
Loop time of 110.174 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.1      | 109.1      | 109.1      |   0.0 | 99.02
Neigh   | 0.56686    | 0.56686    | 0.56686    |   0.0 |  0.51
Comm    | 0.097003   | 0.097003   | 0.097003   |   0.0 |  0.09
Output  | 0.00021529 | 0.00021529 | 0.00021529 |   0.0 |  0.00
Modify  | 0.35624    | 0.35624    | 0.35624    |   0.0 |  0.32
Other   |            | 0.05831    |            |       |  0.05

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

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

Performance: 0.782 ns/day, 30.692 hours/ns, 9.050 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.41     | 109.41     | 109.41     |   0.0 | 99.02
Neigh   | 0.56645    | 0.56645    | 0.56645    |   0.0 |  0.51
Comm    | 0.097259   | 0.097259   | 0.097259   |   0.0 |  0.09
Output  | 0.0002153  | 0.0002153  | 0.0002153  |   0.0 |  0.00
Modify  | 0.35548    | 0.35548    | 0.35548    |   0.0 |  0.32
Other   |            | 0.05839    |            |       |  0.05

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

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

Performance: 0.783 ns/day, 30.664 hours/ns, 9.059 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.31     | 109.31     | 109.31     |   0.0 | 99.02
Neigh   | 0.56587    | 0.56587    | 0.56587    |   0.0 |  0.51
Comm    | 0.096495   | 0.096495   | 0.096495   |   0.0 |  0.09
Output  | 0.0001704  | 0.0001704  | 0.0001704  |   0.0 |  0.00
Modify  | 0.35639    | 0.35639    | 0.35639    |   0.0 |  0.32
Other   |            | 0.05852    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3693 ave        3693 max        3693 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127520 ave      127520 max      127520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.782 ns/day, 30.674 hours/ns, 9.056 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.32     | 109.32     | 109.32     |   0.0 | 99.00
Neigh   | 0.59134    | 0.59134    | 0.59134    |   0.0 |  0.54
Comm    | 0.097217   | 0.097217   | 0.097217   |   0.0 |  0.09
Output  | 0.00016941 | 0.00016941 | 0.00016941 |   0.0 |  0.00
Modify  | 0.357      | 0.357      | 0.357      |   0.0 |  0.32
Other   |            | 0.05856    |            |       |  0.05

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

Total # of neighbors = 127566
Ave neighs/atom = 63.783
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.477050906114, Press = -0.186161336908256
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    193000  -3631.4659     -3631.4659     -3713.2693     -3713.2693      316.58758      316.58758      41919.044      41919.044      327.32293      327.32293    
    194000  -3634.2521     -3634.2521     -3713.6262     -3713.6262      307.18625      307.18625      41961.492      41961.492      243.45353      243.45353    
Loop time of 110.179 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.784 ns/day, 30.605 hours/ns, 9.076 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.1      | 109.1      | 109.1      |   0.0 | 99.02
Neigh   | 0.56674    | 0.56674    | 0.56674    |   0.0 |  0.51
Comm    | 0.096852   | 0.096852   | 0.096852   |   0.0 |  0.09
Output  | 0.00017027 | 0.00017027 | 0.00017027 |   0.0 |  0.00
Modify  | 0.35575    | 0.35575    | 0.35575    |   0.0 |  0.32
Other   |            | 0.05837    |            |       |  0.05

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

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

Performance: 0.784 ns/day, 30.625 hours/ns, 9.070 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.2      | 109.2      | 109.2      |   0.0 | 99.05
Neigh   | 0.54115    | 0.54115    | 0.54115    |   0.0 |  0.49
Comm    | 0.096246   | 0.096246   | 0.096246   |   0.0 |  0.09
Output  | 0.00016992 | 0.00016992 | 0.00016992 |   0.0 |  0.00
Modify  | 0.35593    | 0.35593    | 0.35593    |   0.0 |  0.32
Other   |            | 0.05853    |            |       |  0.05

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

Total # of neighbors = 127272
Ave neighs/atom = 63.636
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.484550155629, Press = -0.153625352296238
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    195000  -3632.7492     -3632.7492     -3714.0428     -3714.0428      314.6149       314.6149       42040.176      42040.176     -37.442005     -37.442005    
    196000  -3631.1414     -3631.1414     -3712.5229     -3712.5229      314.95485      314.95485      42013.765      42013.765      101.04252      101.04252    
Loop time of 110.297 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.22     | 109.22     | 109.22     |   0.0 | 99.02
Neigh   | 0.56596    | 0.56596    | 0.56596    |   0.0 |  0.51
Comm    | 0.096808   | 0.096808   | 0.096808   |   0.0 |  0.09
Output  | 0.00016925 | 0.00016925 | 0.00016925 |   0.0 |  0.00
Modify  | 0.35529    | 0.35529    | 0.35529    |   0.0 |  0.32
Other   |            | 0.05849    |            |       |  0.05

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

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.35     | 104.35     | 104.35     |   0.0 | 99.04
Neigh   | 0.51775    | 0.51775    | 0.51775    |   0.0 |  0.49
Comm    | 0.092375   | 0.092375   | 0.092375   |   0.0 |  0.09
Output  | 0.00015915 | 0.00015915 | 0.00015915 |   0.0 |  0.00
Modify  | 0.34543    | 0.34543    | 0.34543    |   0.0 |  0.33
Other   |            | 0.05679    |            |       |  0.05

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

Total # of neighbors = 127410
Ave neighs/atom = 63.705
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.477278924933, Press = -0.160749513724145
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    197000  -3635.4818     -3635.4818     -3715.5493     -3715.5493      309.86938      309.86938      41963.54       41963.54       41.177317      41.177317    
    198000  -3634.4911     -3634.4911     -3714.1326     -3714.1326      308.22081      308.22081      41928.636      41928.636      270.01574      270.01574    
Loop time of 104.876 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.132 hours/ns, 9.535 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.84     | 103.84     | 103.84     |   0.0 | 99.02
Neigh   | 0.53873    | 0.53873    | 0.53873    |   0.0 |  0.51
Comm    | 0.092896   | 0.092896   | 0.092896   |   0.0 |  0.09
Output  | 0.00016109 | 0.00016109 | 0.00016109 |   0.0 |  0.00
Modify  | 0.34316    | 0.34316    | 0.34316    |   0.0 |  0.33
Other   |            | 0.05687    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3802 ave        3802 max        3802 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127278 ave      127278 max      127278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127278
Ave neighs/atom = 63.639
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.475411000377, Press = -0.118442447982788
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    198000  -3634.4911     -3634.4911     -3714.1326     -3714.1326      308.22081      308.22081      41928.636      41928.636      270.01574      270.01574    
    199000  -3630.9726     -3630.9726     -3711.9711     -3711.9711      313.4725       313.4725       42093.623      42093.623     -223.25616     -223.25616    
Loop time of 105.514 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.309 hours/ns, 9.477 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.51     | 104.51     | 104.51     |   0.0 | 99.04
Neigh   | 0.51391    | 0.51391    | 0.51391    |   0.0 |  0.49
Comm    | 0.09324    | 0.09324    | 0.09324    |   0.0 |  0.09
Output  | 0.00016057 | 0.00016057 | 0.00016057 |   0.0 |  0.00
Modify  | 0.344      | 0.344      | 0.344      |   0.0 |  0.33
Other   |            | 0.05689    |            |       |  0.05

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

Total # of neighbors = 127204
Ave neighs/atom = 63.602
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.483685661281, Press = -0.143764883845815
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    199000  -3630.9726     -3630.9726     -3711.9711     -3711.9711      313.4725       313.4725       42093.623      42093.623     -223.25616     -223.25616    
    200000  -3635.1561     -3635.1561     -3713.2315     -3713.2315      302.16009      302.16009      42046.772      42046.772     -133.18052     -133.18052    
Loop time of 106.284 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.523 hours/ns, 9.409 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.27     | 105.27     | 105.27     |   0.0 | 99.04
Neigh   | 0.52143    | 0.52143    | 0.52143    |   0.0 |  0.49
Comm    | 0.093413   | 0.093413   | 0.093413   |   0.0 |  0.09
Output  | 0.00016164 | 0.00016164 | 0.00016164 |   0.0 |  0.00
Modify  | 0.34605    | 0.34605    | 0.34605    |   0.0 |  0.33
Other   |            | 0.0577     |            |       |  0.05

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

Total # of neighbors = 127250
Ave neighs/atom = 63.625
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.481327920592, Press = -0.28499333489825
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    200000  -3635.1561     -3635.1561     -3713.2315     -3713.2315      302.16009      302.16009      42046.772      42046.772     -133.18052     -133.18052    
    201000  -3632.6896     -3632.6896     -3713.0864     -3713.0864      311.14426      311.14426      41986.323      41986.323      51.999637      51.999637    
Loop time of 104.742 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.095 hours/ns, 9.547 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.71     | 103.71     | 103.71     |   0.0 | 99.01
Neigh   | 0.53908    | 0.53908    | 0.53908    |   0.0 |  0.51
Comm    | 0.091937   | 0.091937   | 0.091937   |   0.0 |  0.09
Output  | 0.00016112 | 0.00016112 | 0.00016112 |   0.0 |  0.00
Modify  | 0.34367    | 0.34367    | 0.34367    |   0.0 |  0.33
Other   |            | 0.05709    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3712 ave        3712 max        3712 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127340 ave      127340 max      127340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127340
Ave neighs/atom = 63.67
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.482423173402, Press = -0.322306354931146
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    201000  -3632.6896     -3632.6896     -3713.0864     -3713.0864      311.14426      311.14426      41986.323      41986.323      51.999637      51.999637    
    202000  -3635.5887     -3635.5887     -3716.745      -3716.745       314.08297      314.08297      41796.636      41796.636      510.82974      510.82974    
Loop time of 104.928 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.147 hours/ns, 9.530 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.9      | 103.9      | 103.9      |   0.0 | 99.02
Neigh   | 0.53578    | 0.53578    | 0.53578    |   0.0 |  0.51
Comm    | 0.092335   | 0.092335   | 0.092335   |   0.0 |  0.09
Output  | 0.00016131 | 0.00016131 | 0.00016131 |   0.0 |  0.00
Modify  | 0.3418     | 0.3418     | 0.3418     |   0.0 |  0.33
Other   |            | 0.0572     |            |       |  0.05

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

Total # of neighbors = 127964
Ave neighs/atom = 63.982
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.472525416254, Press = -0.200348294670262
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    202000  -3635.5887     -3635.5887     -3716.745      -3716.745       314.08297      314.08297      41796.636      41796.636      510.82974      510.82974    
    203000  -3629.7529     -3629.7529     -3712.1149     -3712.1149      318.74931      318.74931      42067.801      42067.801     -125.39247     -125.39247    
Loop time of 104.708 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.68     | 103.68     | 103.68     |   0.0 | 99.02
Neigh   | 0.53802    | 0.53802    | 0.53802    |   0.0 |  0.51
Comm    | 0.09308    | 0.09308    | 0.09308    |   0.0 |  0.09
Output  | 0.00050385 | 0.00050385 | 0.00050385 |   0.0 |  0.00
Modify  | 0.34115    | 0.34115    | 0.34115    |   0.0 |  0.33
Other   |            | 0.05704    |            |       |  0.05

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

Total # of neighbors = 127600
Ave neighs/atom = 63.8
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.46274656808, Press = 0.0809290971321113
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    203000  -3629.7529     -3629.7529     -3712.1149     -3712.1149      318.74931      318.74931      42067.801      42067.801     -125.39247     -125.39247    
    204000  -3632.1582     -3632.1582     -3713.3024     -3713.3024      314.03653      314.03653      42195.035      42195.035     -526.18802     -526.18802    
Loop time of 104.591 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.053 hours/ns, 9.561 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.56     | 103.56     | 103.56     |   0.0 | 99.02
Neigh   | 0.5352     | 0.5352     | 0.5352     |   0.0 |  0.51
Comm    | 0.091794   | 0.091794   | 0.091794   |   0.0 |  0.09
Output  | 0.00020606 | 0.00020606 | 0.00020606 |   0.0 |  0.00
Modify  | 0.34257    | 0.34257    | 0.34257    |   0.0 |  0.33
Other   |            | 0.05679    |            |       |  0.05

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

Total # of neighbors = 126862
Ave neighs/atom = 63.431
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.447676585975, Press = -0.234662903055558
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    204000  -3632.1582     -3632.1582     -3713.3024     -3713.3024      314.03653      314.03653      42195.035      42195.035     -526.18802     -526.18802    
    205000  -3633.5263     -3633.5263     -3713.4381     -3713.4381      309.26709      309.26709      41937.036      41937.036      311.54605      311.54605    
Loop time of 104.51 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.030 hours/ns, 9.568 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.51     | 103.51     | 103.51     |   0.0 | 99.04
Neigh   | 0.51217    | 0.51217    | 0.51217    |   0.0 |  0.49
Comm    | 0.092496   | 0.092496   | 0.092496   |   0.0 |  0.09
Output  | 0.00016178 | 0.00016178 | 0.00016178 |   0.0 |  0.00
Modify  | 0.34212    | 0.34212    | 0.34212    |   0.0 |  0.33
Other   |            | 0.05723    |            |       |  0.05

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

Total # of neighbors = 127380
Ave neighs/atom = 63.69
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.445694272845, Press = -0.31149672471796
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    205000  -3633.5263     -3633.5263     -3713.4381     -3713.4381      309.26709      309.26709      41937.036      41937.036      311.54605      311.54605    
    206000  -3631.0547     -3631.0547     -3712.7245     -3712.7245      316.07051      316.07051      42002.476      42002.476      181.79743      181.79743    
Loop time of 107.634 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.803 ns/day, 29.898 hours/ns, 9.291 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.57     | 106.57     | 106.57     |   0.0 | 99.01
Neigh   | 0.55714    | 0.55714    | 0.55714    |   0.0 |  0.52
Comm    | 0.094514   | 0.094514   | 0.094514   |   0.0 |  0.09
Output  | 0.00016942 | 0.00016942 | 0.00016942 |   0.0 |  0.00
Modify  | 0.35067    | 0.35067    | 0.35067    |   0.0 |  0.33
Other   |            | 0.05834    |            |       |  0.05

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

Total # of neighbors = 127474
Ave neighs/atom = 63.737
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.446983239523, Press = -0.126007687228408
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    206000  -3631.0547     -3631.0547     -3712.7245     -3712.7245      316.07051      316.07051      42002.476      42002.476      181.79743      181.79743    
    207000  -3634.1738     -3634.1738     -3715.6995     -3715.6995      315.51296      315.51296      42108.777      42108.777     -361.78495     -361.78495    
Loop time of 105.569 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.325 hours/ns, 9.472 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.53     | 104.53     | 104.53     |   0.0 | 99.02
Neigh   | 0.54431    | 0.54431    | 0.54431    |   0.0 |  0.52
Comm    | 0.092002   | 0.092002   | 0.092002   |   0.0 |  0.09
Output  | 0.00016041 | 0.00016041 | 0.00016041 |   0.0 |  0.00
Modify  | 0.34551    | 0.34551    | 0.34551    |   0.0 |  0.33
Other   |            | 0.05752    |            |       |  0.05

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

Total # of neighbors = 127056
Ave neighs/atom = 63.528
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.449978500166, Press = -0.0829311743432417
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    207000  -3634.1738     -3634.1738     -3715.6995     -3715.6995      315.51296      315.51296      42108.777      42108.777     -361.78495     -361.78495    
    208000  -3631.867      -3631.867      -3714.3778     -3714.3778      319.32555      319.32555      42137.14       42137.14      -327.48274     -327.48274    
Loop time of 104.996 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.166 hours/ns, 9.524 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.99     | 103.99     | 103.99     |   0.0 | 99.04
Neigh   | 0.51653    | 0.51653    | 0.51653    |   0.0 |  0.49
Comm    | 0.092514   | 0.092514   | 0.092514   |   0.0 |  0.09
Output  | 0.00016236 | 0.00016236 | 0.00016236 |   0.0 |  0.00
Modify  | 0.34438    | 0.34438    | 0.34438    |   0.0 |  0.33
Other   |            | 0.05748    |            |       |  0.05

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

Total # of neighbors = 126940
Ave neighs/atom = 63.47
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.446016556628, Press = -0.251543973256712
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    208000  -3631.867      -3631.867      -3714.3778     -3714.3778      319.32555      319.32555      42137.14       42137.14      -327.48274     -327.48274    
    209000  -3634.3209     -3634.3209     -3715.8341     -3715.8341      315.4644       315.4644       41885.294      41885.294      390.61928      390.61928    
Loop time of 104.579 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.050 hours/ns, 9.562 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.58     | 103.58     | 103.58     |   0.0 | 99.04
Neigh   | 0.51018    | 0.51018    | 0.51018    |   0.0 |  0.49
Comm    | 0.092276   | 0.092276   | 0.092276   |   0.0 |  0.09
Output  | 0.00016208 | 0.00016208 | 0.00016208 |   0.0 |  0.00
Modify  | 0.3419     | 0.3419     | 0.3419     |   0.0 |  0.33
Other   |            | 0.05765    |            |       |  0.06

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

Total # of neighbors = 127224
Ave neighs/atom = 63.612
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.444274446141, Press = -0.200923482938973
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    209000  -3634.3209     -3634.3209     -3715.8341     -3715.8341      315.4644       315.4644       41885.294      41885.294      390.61928      390.61928    
    210000  -3623.1473     -3623.1473     -3706.1849     -3706.1849      321.36402      321.36402      42001.146      42001.146      295.58504      295.58504    
Loop time of 105.611 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.337 hours/ns, 9.469 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.57     | 104.57     | 104.57     |   0.0 | 99.02
Neigh   | 0.54149    | 0.54149    | 0.54149    |   0.0 |  0.51
Comm    | 0.092683   | 0.092683   | 0.092683   |   0.0 |  0.09
Output  | 0.00016147 | 0.00016147 | 0.00016147 |   0.0 |  0.00
Modify  | 0.34562    | 0.34562    | 0.34562    |   0.0 |  0.33
Other   |            | 0.05751    |            |       |  0.05

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

Total # of neighbors = 127940
Ave neighs/atom = 63.97
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.45820704977, Press = 0.00116602522594921
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    210000  -3623.1473     -3623.1473     -3706.1849     -3706.1849      321.36402      321.36402      42001.146      42001.146      295.58504      295.58504    
    211000  -3633.8994     -3633.8994     -3713.6102     -3713.6102      308.48896      308.48896      42124.669      42124.669     -394.51565     -394.51565    
Loop time of 105.287 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.25     | 104.25     | 104.25     |   0.0 | 99.02
Neigh   | 0.54123    | 0.54123    | 0.54123    |   0.0 |  0.51
Comm    | 0.092198   | 0.092198   | 0.092198   |   0.0 |  0.09
Output  | 0.00017034 | 0.00017034 | 0.00017034 |   0.0 |  0.00
Modify  | 0.3451     | 0.3451     | 0.3451     |   0.0 |  0.33
Other   |            | 0.05672    |            |       |  0.05

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

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

Performance: 0.818 ns/day, 29.329 hours/ns, 9.471 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.57     | 104.57     | 104.57     |   0.0 | 99.04
Neigh   | 0.51923    | 0.51923    | 0.51923    |   0.0 |  0.49
Comm    | 0.09271    | 0.09271    | 0.09271    |   0.0 |  0.09
Output  | 0.00016478 | 0.00016478 | 0.00016478 |   0.0 |  0.00
Modify  | 0.34538    | 0.34538    | 0.34538    |   0.0 |  0.33
Other   |            | 0.05681    |            |       |  0.05

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

Total # of neighbors = 127326
Ave neighs/atom = 63.663
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.463364242347, Press = -0.296058536510638
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    212000  -3632.249      -3632.249      -3712.2721     -3712.2721      309.69753      309.69753      42024.44       42024.44      -7.835867      -7.835867     
    213000  -3634.7101     -3634.7101     -3715.2031     -3715.2031      311.51625      311.51625      41880.067      41880.067      447.54392      447.54392    
Loop time of 104.994 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.165 hours/ns, 9.524 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.98     | 103.98     | 103.98     |   0.0 | 99.04
Neigh   | 0.51582    | 0.51582    | 0.51582    |   0.0 |  0.49
Comm    | 0.092593   | 0.092593   | 0.092593   |   0.0 |  0.09
Output  | 0.00016075 | 0.00016075 | 0.00016075 |   0.0 |  0.00
Modify  | 0.34391    | 0.34391    | 0.34391    |   0.0 |  0.33
Other   |            | 0.05747    |            |       |  0.05

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

Total # of neighbors = 127446
Ave neighs/atom = 63.723
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.46320010701, Press = -0.210716001250315
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    213000  -3634.7101     -3634.7101     -3715.2031     -3715.2031      311.51625      311.51625      41880.067      41880.067      447.54392      447.54392    
    214000  -3630.7029     -3630.7029     -3715.1541     -3715.1541      326.83485      326.83485      42167.197      42167.197     -333.11862     -333.11862    
Loop time of 104.786 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.107 hours/ns, 9.543 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.76     | 103.76     | 103.76     |   0.0 | 99.02
Neigh   | 0.53561    | 0.53561    | 0.53561    |   0.0 |  0.51
Comm    | 0.092077   | 0.092077   | 0.092077   |   0.0 |  0.09
Output  | 0.00016089 | 0.00016089 | 0.00016089 |   0.0 |  0.00
Modify  | 0.3426     | 0.3426     | 0.3426     |   0.0 |  0.33
Other   |            | 0.05709    |            |       |  0.05

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

Total # of neighbors = 127092
Ave neighs/atom = 63.546
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.454750884635, Press = -0.0442684139968833
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    214000  -3630.7029     -3630.7029     -3715.1541     -3715.1541      326.83485      326.83485      42167.197      42167.197     -333.11862     -333.11862    
    215000  -3633.7662     -3633.7662     -3715.6345     -3715.6345      316.83886      316.83886      42197.385      42197.385     -532.93386     -532.93386    
Loop time of 104.5 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.028 hours/ns, 9.569 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.48     | 103.48     | 103.48     |   0.0 | 99.02
Neigh   | 0.53536    | 0.53536    | 0.53536    |   0.0 |  0.51
Comm    | 0.092183   | 0.092183   | 0.092183   |   0.0 |  0.09
Output  | 0.00015989 | 0.00015989 | 0.00015989 |   0.0 |  0.00
Modify  | 0.34024    | 0.34024    | 0.34024    |   0.0 |  0.33
Other   |            | 0.05718    |            |       |  0.05

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

Total # of neighbors = 126684
Ave neighs/atom = 63.342
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.451166649646, Press = -0.29594976180291
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    215000  -3633.7662     -3633.7662     -3715.6345     -3715.6345      316.83886      316.83886      42197.385      42197.385     -532.93386     -532.93386    
    216000  -3630.0792     -3630.0792     -3713.64       -3713.64        323.38889      323.38889      42006.004      42006.004      161.49395      161.49395    
Loop time of 104.68 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.078 hours/ns, 9.553 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.65     | 103.65     | 103.65     |   0.0 | 99.02
Neigh   | 0.53496    | 0.53496    | 0.53496    |   0.0 |  0.51
Comm    | 0.092822   | 0.092822   | 0.092822   |   0.0 |  0.09
Output  | 0.00022707 | 0.00022707 | 0.00022707 |   0.0 |  0.00
Modify  | 0.34246    | 0.34246    | 0.34246    |   0.0 |  0.33
Other   |            | 0.05709    |            |       |  0.05

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

Total # of neighbors = 127340
Ave neighs/atom = 63.67
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.458623872795, Press = -0.305935886514866
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    216000  -3630.0792     -3630.0792     -3713.64       -3713.64        323.38889      323.38889      42006.004      42006.004      161.49395      161.49395    
    217000  -3631.9105     -3631.9105     -3715.0821     -3715.0821      321.88263      321.88263      42028.777      42028.777     -61.875914     -61.875914    
Loop time of 111.077 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.778 ns/day, 30.855 hours/ns, 9.003 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.99     | 109.99     | 109.99     |   0.0 | 99.02
Neigh   | 0.56775    | 0.56775    | 0.56775    |   0.0 |  0.51
Comm    | 0.097787   | 0.097787   | 0.097787   |   0.0 |  0.09
Output  | 0.00021218 | 0.00021218 | 0.00021218 |   0.0 |  0.00
Modify  | 0.35982    | 0.35982    | 0.35982    |   0.0 |  0.32
Other   |            | 0.05882    |            |       |  0.05

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

Total # of neighbors = 127268
Ave neighs/atom = 63.634
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.452920890382, Press = -0.0602394406725122
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    217000  -3631.9105     -3631.9105     -3715.0821     -3715.0821      321.88263      321.88263      42028.777      42028.777     -61.875914     -61.875914    
    218000  -3632.3757     -3632.3757     -3711.5852     -3711.5852      306.54907      306.54907      42122.098      42122.098     -281.47448     -281.47448    
Loop time of 105.887 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.413 hours/ns, 9.444 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.84     | 104.84     | 104.84     |   0.0 | 99.02
Neigh   | 0.54517    | 0.54517    | 0.54517    |   0.0 |  0.51
Comm    | 0.093346   | 0.093346   | 0.093346   |   0.0 |  0.09
Output  | 0.00016106 | 0.00016106 | 0.00016106 |   0.0 |  0.00
Modify  | 0.34586    | 0.34586    | 0.34586    |   0.0 |  0.33
Other   |            | 0.05776    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3724 ave        3724 max        3724 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127216 ave      127216 max      127216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127216
Ave neighs/atom = 63.608
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.456079775602, Press = -0.256906032849641
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    218000  -3632.3757     -3632.3757     -3711.5852     -3711.5852      306.54907      306.54907      42122.098      42122.098     -281.47448     -281.47448    
    219000  -3636.2312     -3636.2312     -3715.8282     -3715.8282      308.04862      308.04862      41895.949      41895.949      287.17226      287.17226    
Loop time of 105.565 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.324 hours/ns, 9.473 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.53     | 104.53     | 104.53     |   0.0 | 99.02
Neigh   | 0.54149    | 0.54149    | 0.54149    |   0.0 |  0.51
Comm    | 0.093375   | 0.093375   | 0.093375   |   0.0 |  0.09
Output  | 0.00016108 | 0.00016108 | 0.00016108 |   0.0 |  0.00
Modify  | 0.34598    | 0.34598    | 0.34598    |   0.0 |  0.33
Other   |            | 0.05713    |            |       |  0.05

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

Total # of neighbors = 127480
Ave neighs/atom = 63.74
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.44752025457, Press = -0.313615223769193
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    219000  -3636.2312     -3636.2312     -3715.8282     -3715.8282      308.04862      308.04862      41895.949      41895.949      287.17226      287.17226    
    220000  -3631.9854     -3631.9854     -3711.6113     -3711.6113      308.16056      308.16056      41975.984      41975.984      162.69399      162.69399    
Loop time of 105.846 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.402 hours/ns, 9.448 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.83     | 104.83     | 104.83     |   0.0 | 99.04
Neigh   | 0.51901    | 0.51901    | 0.51901    |   0.0 |  0.49
Comm    | 0.092675   | 0.092675   | 0.092675   |   0.0 |  0.09
Output  | 0.00016146 | 0.00016146 | 0.00016146 |   0.0 |  0.00
Modify  | 0.34595    | 0.34595    | 0.34595    |   0.0 |  0.33
Other   |            | 0.05749    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3815 ave        3815 max        3815 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127434 ave      127434 max      127434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127434
Ave neighs/atom = 63.717
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.430728782911, Press = -0.099773037175179
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    220000  -3631.9854     -3631.9854     -3711.6113     -3711.6113      308.16056      308.16056      41975.984      41975.984      162.69399      162.69399    
    221000  -3635.1427     -3635.1427     -3714.6885     -3714.6885      307.85014      307.85014      42016.925      42016.925     -14.229692     -14.229692    
Loop time of 104.481 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.022 hours/ns, 9.571 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.46     | 103.46     | 103.46     |   0.0 | 99.02
Neigh   | 0.53519    | 0.53519    | 0.53519    |   0.0 |  0.51
Comm    | 0.091428   | 0.091428   | 0.091428   |   0.0 |  0.09
Output  | 0.00015957 | 0.00015957 | 0.00015957 |   0.0 |  0.00
Modify  | 0.3413     | 0.3413     | 0.3413     |   0.0 |  0.33
Other   |            | 0.05733    |            |       |  0.05

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

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

Performance: 0.826 ns/day, 29.072 hours/ns, 9.555 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.63     | 103.63     | 103.63     |   0.0 | 99.02
Neigh   | 0.53651    | 0.53651    | 0.53651    |   0.0 |  0.51
Comm    | 0.091977   | 0.091977   | 0.091977   |   0.0 |  0.09
Output  | 0.00016067 | 0.00016067 | 0.00016067 |   0.0 |  0.00
Modify  | 0.34413    | 0.34413    | 0.34413    |   0.0 |  0.33
Other   |            | 0.05724    |            |       |  0.05

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

Total # of neighbors = 127228
Ave neighs/atom = 63.614
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.428470802534, Press = -0.076388517475871
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    222000  -3634.2358     -3634.2358     -3714.3422     -3714.3422      310.02011      310.02011      42098.185      42098.185     -296.37263     -296.37263    
    223000  -3635.2975     -3635.2975     -3714.9999     -3714.9999      308.45668      308.45668      42124.866      42124.866     -471.36717     -471.36717    
Loop time of 105.483 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.301 hours/ns, 9.480 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.47     | 104.47     | 104.47     |   0.0 | 99.04
Neigh   | 0.51917    | 0.51917    | 0.51917    |   0.0 |  0.49
Comm    | 0.092009   | 0.092009   | 0.092009   |   0.0 |  0.09
Output  | 0.00016095 | 0.00016095 | 0.00016095 |   0.0 |  0.00
Modify  | 0.34483    | 0.34483    | 0.34483    |   0.0 |  0.33
Other   |            | 0.05744    |            |       |  0.05

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

Total # of neighbors = 126880
Ave neighs/atom = 63.44
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.432862955096, Press = -0.401547139755597
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    223000  -3635.2975     -3635.2975     -3714.9999     -3714.9999      308.45668      308.45668      42124.866      42124.866     -471.36717     -471.36717    
    224000  -3629.8331     -3629.8331     -3712.135      -3712.135       318.51701      318.51701      41927.339      41927.339      434.98978      434.98978    
Loop time of 104.589 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.053 hours/ns, 9.561 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.56     | 103.56     | 103.56     |   0.0 | 99.01
Neigh   | 0.54103    | 0.54103    | 0.54103    |   0.0 |  0.52
Comm    | 0.091652   | 0.091652   | 0.091652   |   0.0 |  0.09
Output  | 0.00024227 | 0.00024227 | 0.00024227 |   0.0 |  0.00
Modify  | 0.34131    | 0.34131    | 0.34131    |   0.0 |  0.33
Other   |            | 0.05645    |            |       |  0.05

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

Total # of neighbors = 127410
Ave neighs/atom = 63.705
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.434643726117, Press = -0.35130792070299
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    224000  -3629.8331     -3629.8331     -3712.135      -3712.135       318.51701      318.51701      41927.339      41927.339      434.98978      434.98978    
    225000  -3634.4378     -3634.4378     -3713.3665     -3713.3665      305.46247      305.46247      41914.002      41914.002      310.46801      310.46801    
Loop time of 107.57 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.803 ns/day, 29.881 hours/ns, 9.296 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.54     | 106.54     | 106.54     |   0.0 | 99.04
Neigh   | 0.52888    | 0.52888    | 0.52888    |   0.0 |  0.49
Comm    | 0.093883   | 0.093883   | 0.093883   |   0.0 |  0.09
Output  | 0.00018021 | 0.00018021 | 0.00018021 |   0.0 |  0.00
Modify  | 0.34941    | 0.34941    | 0.34941    |   0.0 |  0.32
Other   |            | 0.05772    |            |       |  0.05

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

Total # of neighbors = 127432
Ave neighs/atom = 63.716
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.440346442832, Press = -0.0854943412159704
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    225000  -3634.4378     -3634.4378     -3713.3665     -3713.3665      305.46247      305.46247      41914.002      41914.002      310.46801      310.46801    
    226000  -3631.9241     -3631.9241     -3714.4133     -3714.4133      319.24163      319.24163      42124.847      42124.847     -291.2514      -291.2514     
Loop time of 104.798 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.110 hours/ns, 9.542 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.77     | 103.77     | 103.77     |   0.0 | 99.02
Neigh   | 0.53736    | 0.53736    | 0.53736    |   0.0 |  0.51
Comm    | 0.093058   | 0.093058   | 0.093058   |   0.0 |  0.09
Output  | 0.0001601  | 0.0001601  | 0.0001601  |   0.0 |  0.00
Modify  | 0.34272    | 0.34272    | 0.34272    |   0.0 |  0.33
Other   |            | 0.05744    |            |       |  0.05

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

Total # of neighbors = 126964
Ave neighs/atom = 63.482
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.43725654959, Press = -0.235879497397055
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    226000  -3631.9241     -3631.9241     -3714.4133     -3714.4133      319.24163      319.24163      42124.847      42124.847     -291.2514      -291.2514     
    227000  -3630.1424     -3630.1424     -3711.3745     -3711.3745      314.37645      314.37645      41950.035      41950.035      405.5468       405.5468     
Loop time of 106.484 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.579 hours/ns, 9.391 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.46     | 105.46     | 105.46     |   0.0 | 99.04
Neigh   | 0.52168    | 0.52168    | 0.52168    |   0.0 |  0.49
Comm    | 0.092771   | 0.092771   | 0.092771   |   0.0 |  0.09
Output  | 0.00016106 | 0.00016106 | 0.00016106 |   0.0 |  0.00
Modify  | 0.3471     | 0.3471     | 0.3471     |   0.0 |  0.33
Other   |            | 0.05726    |            |       |  0.05

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

Total # of neighbors = 127214
Ave neighs/atom = 63.607
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.442213015519, Press = -0.219962893670086
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    227000  -3630.1424     -3630.1424     -3711.3745     -3711.3745      314.37645      314.37645      41950.035      41950.035      405.5468       405.5468     
    228000  -3632.7693     -3632.7693     -3714.8138     -3714.8138      317.52059      317.52059      42078.53       42078.53      -205.43074     -205.43074    
Loop time of 104.393 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 28.998 hours/ns, 9.579 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.36     | 103.36     | 103.36     |   0.0 | 99.02
Neigh   | 0.5373     | 0.5373     | 0.5373     |   0.0 |  0.51
Comm    | 0.09158    | 0.09158    | 0.09158    |   0.0 |  0.09
Output  | 0.00016041 | 0.00016041 | 0.00016041 |   0.0 |  0.00
Modify  | 0.34159    | 0.34159    | 0.34159    |   0.0 |  0.33
Other   |            | 0.05746    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3819 ave        3819 max        3819 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127172 ave      127172 max      127172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127172
Ave neighs/atom = 63.586
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.451475184424, Press = -0.136601950205164
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    228000  -3632.7693     -3632.7693     -3714.8138     -3714.8138      317.52059      317.52059      42078.53       42078.53      -205.43074     -205.43074    
    229000  -3628.7926     -3628.7926     -3709.6502     -3709.6502      312.92763      312.92763      42218.135      42218.135     -511.66936     -511.66936    
Loop time of 106.439 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.566 hours/ns, 9.395 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.4      | 105.4      | 105.4      |   0.0 | 99.02
Neigh   | 0.5428     | 0.5428     | 0.5428     |   0.0 |  0.51
Comm    | 0.093152   | 0.093152   | 0.093152   |   0.0 |  0.09
Output  | 0.00020209 | 0.00020209 | 0.00020209 |   0.0 |  0.00
Modify  | 0.34759    | 0.34759    | 0.34759    |   0.0 |  0.33
Other   |            | 0.05766    |            |       |  0.05

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

Total # of neighbors = 127168
Ave neighs/atom = 63.584
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.451251833261, Press = -0.193790803133088
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    229000  -3628.7926     -3628.7926     -3709.6502     -3709.6502      312.92763      312.92763      42218.135      42218.135     -511.66936     -511.66936    
    230000  -3632.3756     -3632.3756     -3714.0272     -3714.0272      316.00002      316.00002      42030.567      42030.567     -80.405623     -80.405623    
Loop time of 104.477 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.021 hours/ns, 9.571 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.45     | 103.45     | 103.45     |   0.0 | 99.02
Neigh   | 0.53443    | 0.53443    | 0.53443    |   0.0 |  0.51
Comm    | 0.092111   | 0.092111   | 0.092111   |   0.0 |  0.09
Output  | 0.00016139 | 0.00016139 | 0.00016139 |   0.0 |  0.00
Modify  | 0.34258    | 0.34258    | 0.34258    |   0.0 |  0.33
Other   |            | 0.05696    |            |       |  0.05

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

Total # of neighbors = 127194
Ave neighs/atom = 63.597
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.460661911855, Press = -0.32253882682099
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    230000  -3632.3756     -3632.3756     -3714.0272     -3714.0272      316.00002      316.00002      42030.567      42030.567     -80.405623     -80.405623    
    231000  -3633.8355     -3633.8355     -3716.3899     -3716.3899      319.49402      319.49402      41712.728      41712.728      1005.5353      1005.5353    
Loop time of 105.418 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.39     | 104.39     | 104.39     |   0.0 | 99.02
Neigh   | 0.53797    | 0.53797    | 0.53797    |   0.0 |  0.51
Comm    | 0.092937   | 0.092937   | 0.092937   |   0.0 |  0.09
Output  | 0.00016104 | 0.00016104 | 0.00016104 |   0.0 |  0.00
Modify  | 0.34217    | 0.34217    | 0.34217    |   0.0 |  0.32
Other   |            | 0.05723    |            |       |  0.05

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

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

Performance: 0.812 ns/day, 29.539 hours/ns, 9.404 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.29     | 105.29     | 105.29     |   0.0 | 99.02
Neigh   | 0.54652    | 0.54652    | 0.54652    |   0.0 |  0.51
Comm    | 0.094931   | 0.094931   | 0.094931   |   0.0 |  0.09
Output  | 0.00016934 | 0.00016934 | 0.00016934 |   0.0 |  0.00
Modify  | 0.34533    | 0.34533    | 0.34533    |   0.0 |  0.32
Other   |            | 0.05761    |            |       |  0.05

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

Total # of neighbors = 127334
Ave neighs/atom = 63.667
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.446911042576, Press = 0.0720549524113185
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    232000  -3630.6779     -3630.6779     -3713.5255     -3713.5255      320.6291       320.6291       42082.391      42082.391     -249.22985     -249.22985    
    233000  -3632.6252     -3632.6252     -3714.0226     -3714.0226      315.01623      315.01623      42193.045      42193.045     -553.85981     -553.85981    
Loop time of 104.762 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.101 hours/ns, 9.545 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.73     | 103.73     | 103.73     |   0.0 | 99.02
Neigh   | 0.5391     | 0.5391     | 0.5391     |   0.0 |  0.51
Comm    | 0.092907   | 0.092907   | 0.092907   |   0.0 |  0.09
Output  | 0.00016077 | 0.00016077 | 0.00016077 |   0.0 |  0.00
Modify  | 0.34271    | 0.34271    | 0.34271    |   0.0 |  0.33
Other   |            | 0.05659    |            |       |  0.05

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

Total # of neighbors = 126930
Ave neighs/atom = 63.465
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.436340986436, Press = -0.185526471458531
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    233000  -3632.6252     -3632.6252     -3714.0226     -3714.0226      315.01623      315.01623      42193.045      42193.045     -553.85981     -553.85981    
    234000  -3633.0997     -3633.0997     -3713.396      -3713.396       310.75482      310.75482      42087.672      42087.672     -228.58982     -228.58982    
Loop time of 105.664 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.351 hours/ns, 9.464 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.63     | 104.63     | 104.63     |   0.0 | 99.02
Neigh   | 0.54227    | 0.54227    | 0.54227    |   0.0 |  0.51
Comm    | 0.093183   | 0.093183   | 0.093183   |   0.0 |  0.09
Output  | 0.00015863 | 0.00015863 | 0.00015863 |   0.0 |  0.00
Modify  | 0.34592    | 0.34592    | 0.34592    |   0.0 |  0.33
Other   |            | 0.05698    |            |       |  0.05

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

Total # of neighbors = 127160
Ave neighs/atom = 63.58
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.429355748258, Press = -0.301425755823444
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    234000  -3633.0997     -3633.0997     -3713.396      -3713.396       310.75482      310.75482      42087.672      42087.672     -228.58982     -228.58982    
    235000  -3633.3682     -3633.3682     -3714.1116     -3714.1116      312.48539      312.48539      41900.725      41900.725      219.42081      219.42081    
Loop time of 106.472 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.576 hours/ns, 9.392 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.43     | 105.43     | 105.43     |   0.0 | 99.02
Neigh   | 0.547      | 0.547      | 0.547      |   0.0 |  0.51
Comm    | 0.093264   | 0.093264   | 0.093264   |   0.0 |  0.09
Output  | 0.00021117 | 0.00021117 | 0.00021117 |   0.0 |  0.00
Modify  | 0.34656    | 0.34656    | 0.34656    |   0.0 |  0.33
Other   |            | 0.05709    |            |       |  0.05

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

Total # of neighbors = 127668
Ave neighs/atom = 63.834
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.430135369563, Press = -0.325177508183397
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    235000  -3633.3682     -3633.3682     -3714.1116     -3714.1116      312.48539      312.48539      41900.725      41900.725      219.42081      219.42081    
    236000  -3630.6608     -3630.6608     -3711.9331     -3711.9331      314.53203      314.53203      41952.229      41952.229      247.71393      247.71393    
Loop time of 105.204 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.22     | 104.22     | 104.22     |   0.0 | 99.07
Neigh   | 0.4887     | 0.4887     | 0.4887     |   0.0 |  0.46
Comm    | 0.091871   | 0.091871   | 0.091871   |   0.0 |  0.09
Output  | 0.00016105 | 0.00016105 | 0.00016105 |   0.0 |  0.00
Modify  | 0.34354    | 0.34354    | 0.34354    |   0.0 |  0.33
Other   |            | 0.05742    |            |       |  0.05

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

Total # of neighbors = 127496
Ave neighs/atom = 63.748
Neighbor list builds = 21
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.420360933065, Press = -0.0845563997112807
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    236000  -3630.6608     -3630.6608     -3711.9331     -3711.9331      314.53203      314.53203      41952.229      41952.229      247.71393      247.71393    
    237000  -3633.4996     -3633.4996     -3712.0308     -3712.0308      303.92382      303.92382      42066.639      42066.639     -135.57927     -135.57927    
Loop time of 106.359 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.544 hours/ns, 9.402 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.33     | 105.33     | 105.33     |   0.0 | 99.04
Neigh   | 0.52744    | 0.52744    | 0.52744    |   0.0 |  0.50
Comm    | 0.093485   | 0.093485   | 0.093485   |   0.0 |  0.09
Output  | 0.00020419 | 0.00020419 | 0.00020419 |   0.0 |  0.00
Modify  | 0.34809    | 0.34809    | 0.34809    |   0.0 |  0.33
Other   |            | 0.05712    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3675 ave        3675 max        3675 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127344 ave      127344 max      127344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127344
Ave neighs/atom = 63.672
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.41460755777, Press = -0.19204918121818
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    237000  -3633.4996     -3633.4996     -3712.0308     -3712.0308      303.92382      303.92382      42066.639      42066.639     -135.57927     -135.57927    
    238000  -3635.224      -3635.224      -3716.4391     -3716.4391      314.311        314.311        42028.01       42028.01      -129.28772     -129.28772    
Loop time of 105.379 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.34     | 104.34     | 104.34     |   0.0 | 99.02
Neigh   | 0.54375    | 0.54375    | 0.54375    |   0.0 |  0.52
Comm    | 0.093725   | 0.093725   | 0.093725   |   0.0 |  0.09
Output  | 0.00016062 | 0.00016062 | 0.00016062 |   0.0 |  0.00
Modify  | 0.34261    | 0.34261    | 0.34261    |   0.0 |  0.33
Other   |            | 0.05707    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3801 ave        3801 max        3801 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127240 ave      127240 max      127240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127240
Ave neighs/atom = 63.62
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.402269198764, Press = -0.224155994346497
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    238000  -3635.224      -3635.224      -3716.4391     -3716.4391      314.311        314.311        42028.01       42028.01      -129.28772     -129.28772    
    239000  -3631.0817     -3631.0817     -3713.3803     -3713.3803      318.50399      318.50399      42024.908      42024.908      36.509726      36.509726    
Loop time of 106.142 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.484 hours/ns, 9.421 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.1      | 105.1      | 105.1      |   0.0 | 99.02
Neigh   | 0.54645    | 0.54645    | 0.54645    |   0.0 |  0.51
Comm    | 0.093963   | 0.093963   | 0.093963   |   0.0 |  0.09
Output  | 0.0001691  | 0.0001691  | 0.0001691  |   0.0 |  0.00
Modify  | 0.34671    | 0.34671    | 0.34671    |   0.0 |  0.33
Other   |            | 0.05717    |            |       |  0.05

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

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

Performance: 0.822 ns/day, 29.195 hours/ns, 9.515 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.1      | 104.1      | 104.1      |   0.0 | 99.04
Neigh   | 0.51333    | 0.51333    | 0.51333    |   0.0 |  0.49
Comm    | 0.091771   | 0.091771   | 0.091771   |   0.0 |  0.09
Output  | 0.00016149 | 0.00016149 | 0.00016149 |   0.0 |  0.00
Modify  | 0.34396    | 0.34396    | 0.34396    |   0.0 |  0.33
Other   |            | 0.05698    |            |       |  0.05

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

Total # of neighbors = 127532
Ave neighs/atom = 63.766
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.393395416371, Press = -0.200977579563441
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    240000  -3634.4026     -3634.4026     -3714.8739     -3714.8739      311.43251      311.43251      41909.18       41909.18       339.22853      339.22853    
    241000  -3629.5366     -3629.5366     -3711.4158     -3711.4158      316.88097      316.88097      42015.638      42015.638      160.56475      160.56475    
Loop time of 104.579 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.050 hours/ns, 9.562 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.55     | 103.55     | 103.55     |   0.0 | 99.02
Neigh   | 0.53484    | 0.53484    | 0.53484    |   0.0 |  0.51
Comm    | 0.092578   | 0.092578   | 0.092578   |   0.0 |  0.09
Output  | 0.00016161 | 0.00016161 | 0.00016161 |   0.0 |  0.00
Modify  | 0.34132    | 0.34132    | 0.34132    |   0.0 |  0.33
Other   |            | 0.05706    |            |       |  0.05

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

Total # of neighbors = 127398
Ave neighs/atom = 63.699
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.399492108296, Press = -0.146343830938493
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    241000  -3629.5366     -3629.5366     -3711.4158     -3711.4158      316.88097      316.88097      42015.638      42015.638      160.56475      160.56475    
    242000  -3631.2829     -3631.2829     -3714.3863     -3714.3863      321.61868      321.61868      42122.043      42122.043     -253.01008     -253.01008    
Loop time of 104.751 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.74     | 103.74     | 103.74     |   0.0 | 99.04
Neigh   | 0.51396    | 0.51396    | 0.51396    |   0.0 |  0.49
Comm    | 0.091906   | 0.091906   | 0.091906   |   0.0 |  0.09
Output  | 0.00016238 | 0.00016238 | 0.00016238 |   0.0 |  0.00
Modify  | 0.34398    | 0.34398    | 0.34398    |   0.0 |  0.33
Other   |            | 0.05675    |            |       |  0.05

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

Total # of neighbors = 127336
Ave neighs/atom = 63.668
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.397446682528, Press = -0.0189613974352366
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    242000  -3631.2829     -3631.2829     -3714.3863     -3714.3863      321.61868      321.61868      42122.043      42122.043     -253.01008     -253.01008    
    243000  -3637.2077     -3637.2077     -3715.4312     -3715.4312      302.73271      302.73271      42048.601      42048.601     -169.61294     -169.61294    
Loop time of 104.496 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.027 hours/ns, 9.570 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.47     | 103.47     | 103.47     |   0.0 | 99.02
Neigh   | 0.53507    | 0.53507    | 0.53507    |   0.0 |  0.51
Comm    | 0.092659   | 0.092659   | 0.092659   |   0.0 |  0.09
Output  | 0.00016155 | 0.00016155 | 0.00016155 |   0.0 |  0.00
Modify  | 0.34171    | 0.34171    | 0.34171    |   0.0 |  0.33
Other   |            | 0.05679    |            |       |  0.05

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

Total # of neighbors = 127104
Ave neighs/atom = 63.552
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.389653878479, Press = -0.202203542437522
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    243000  -3637.2077     -3637.2077     -3715.4312     -3715.4312      302.73271      302.73271      42048.601      42048.601     -169.61294     -169.61294    
    244000  -3632.1486     -3632.1486     -3713.8734     -3713.8734      316.28329      316.28329      42082.796      42082.796     -76.618605     -76.618605    
Loop time of 104.603 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.056 hours/ns, 9.560 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.6      | 103.6      | 103.6      |   0.0 | 99.04
Neigh   | 0.51237    | 0.51237    | 0.51237    |   0.0 |  0.49
Comm    | 0.092429   | 0.092429   | 0.092429   |   0.0 |  0.09
Output  | 0.00015864 | 0.00015864 | 0.00015864 |   0.0 |  0.00
Modify  | 0.34014    | 0.34014    | 0.34014    |   0.0 |  0.33
Other   |            | 0.05715    |            |       |  0.05

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

Total # of neighbors = 126980
Ave neighs/atom = 63.49
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.376261232, Press = -0.222486591783756
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    244000  -3632.1486     -3632.1486     -3713.8734     -3713.8734      316.28329      316.28329      42082.796      42082.796     -76.618605     -76.618605    
    245000  -3632.2787     -3632.2787     -3713.5783     -3713.5783      314.63787      314.63787      42010.831      42010.831      70.510939      70.510939    
Loop time of 108.142 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.799 ns/day, 30.040 hours/ns, 9.247 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.08     | 107.08     | 107.08     |   0.0 | 99.02
Neigh   | 0.5552     | 0.5552     | 0.5552     |   0.0 |  0.51
Comm    | 0.095196   | 0.095196   | 0.095196   |   0.0 |  0.09
Output  | 0.00022022 | 0.00022022 | 0.00022022 |   0.0 |  0.00
Modify  | 0.35335    | 0.35335    | 0.35335    |   0.0 |  0.33
Other   |            | 0.05793    |            |       |  0.05

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

Total # of neighbors = 127348
Ave neighs/atom = 63.674
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.376596261593, Press = -0.233079222432115
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    245000  -3632.2787     -3632.2787     -3713.5783     -3713.5783      314.63787      314.63787      42010.831      42010.831      70.510939      70.510939    
    246000  -3634.4945     -3634.4945     -3715.7275     -3715.7275      314.38022      314.38022      41862.874      41862.874      443.63088      443.63088    
Loop time of 106.21 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.503 hours/ns, 9.415 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.2      | 105.2      | 105.2      |   0.0 | 99.04
Neigh   | 0.51944    | 0.51944    | 0.51944    |   0.0 |  0.49
Comm    | 0.092936   | 0.092936   | 0.092936   |   0.0 |  0.09
Output  | 0.00016091 | 0.00016091 | 0.00016091 |   0.0 |  0.00
Modify  | 0.34448    | 0.34448    | 0.34448    |   0.0 |  0.32
Other   |            | 0.05734    |            |       |  0.05

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

Total # of neighbors = 127470
Ave neighs/atom = 63.735
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.369413456584, Press = -0.144256502156326
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    246000  -3634.4945     -3634.4945     -3715.7275     -3715.7275      314.38022      314.38022      41862.874      41862.874      443.63088      443.63088    
    247000  -3633.0818     -3633.0818     -3713.4918     -3713.4918      311.19515      311.19515      41936.309      41936.309      118.94916      118.94916    
Loop time of 106.659 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.628 hours/ns, 9.376 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.61     | 105.61     | 105.61     |   0.0 | 99.02
Neigh   | 0.54827    | 0.54827    | 0.54827    |   0.0 |  0.51
Comm    | 0.093833   | 0.093833   | 0.093833   |   0.0 |  0.09
Output  | 0.00021622 | 0.00021622 | 0.00021622 |   0.0 |  0.00
Modify  | 0.34764    | 0.34764    | 0.34764    |   0.0 |  0.33
Other   |            | 0.05774    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3803 ave        3803 max        3803 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127644 ave      127644 max      127644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127644
Ave neighs/atom = 63.822
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.371750306268, Press = -0.130218908052087
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    247000  -3633.0818     -3633.0818     -3713.4918     -3713.4918      311.19515      311.19515      41936.309      41936.309      118.94916      118.94916    
    248000  -3631.3013     -3631.3013     -3711.0197     -3711.0197      308.51825      308.51825      42254.629      42254.629     -622.66242     -622.66242    
Loop time of 106.414 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.559 hours/ns, 9.397 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.39     | 105.39     | 105.39     |   0.0 | 99.04
Neigh   | 0.52448    | 0.52448    | 0.52448    |   0.0 |  0.49
Comm    | 0.094251   | 0.094251   | 0.094251   |   0.0 |  0.09
Output  | 0.00016884 | 0.00016884 | 0.00016884 |   0.0 |  0.00
Modify  | 0.3469     | 0.3469     | 0.3469     |   0.0 |  0.33
Other   |            | 0.05776    |            |       |  0.05

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

Total # of neighbors = 126842
Ave neighs/atom = 63.421
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.367440691587, Press = -0.158051519570432
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    248000  -3631.3013     -3631.3013     -3711.0197     -3711.0197      308.51825      308.51825      42254.629      42254.629     -622.66242     -622.66242    
    249000  -3633.4594     -3633.4594     -3713.5518     -3713.5518      309.9661       309.9661       42171.897      42171.897     -510.86409     -510.86409    
Loop time of 110.768 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.780 ns/day, 30.769 hours/ns, 9.028 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.68     | 109.68     | 109.68     |   0.0 | 99.02
Neigh   | 0.56831    | 0.56831    | 0.56831    |   0.0 |  0.51
Comm    | 0.097033   | 0.097033   | 0.097033   |   0.0 |  0.09
Output  | 0.00016039 | 0.00016039 | 0.00016039 |   0.0 |  0.00
Modify  | 0.36012    | 0.36012    | 0.36012    |   0.0 |  0.33
Other   |            | 0.05927    |            |       |  0.05

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

Total # of neighbors = 126604
Ave neighs/atom = 63.302
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.358791130546, Press = -0.46785798630191
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    249000  -3633.4594     -3633.4594     -3713.5518     -3713.5518      309.9661       309.9661       42171.897      42171.897     -510.86409     -510.86409    
    250000  -3632.1496     -3632.1496     -3712.2303     -3712.2303      309.92061      309.92061      41868.903      41868.903      420.28282      420.28282    
Loop time of 104.881 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.134 hours/ns, 9.535 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.83     | 103.83     | 103.83     |   0.0 | 99.00
Neigh   | 0.56042    | 0.56042    | 0.56042    |   0.0 |  0.53
Comm    | 0.092387   | 0.092387   | 0.092387   |   0.0 |  0.09
Output  | 0.00015959 | 0.00015959 | 0.00015959 |   0.0 |  0.00
Modify  | 0.34373    | 0.34373    | 0.34373    |   0.0 |  0.33
Other   |            | 0.05671    |            |       |  0.05

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

Total # of neighbors = 127796
Ave neighs/atom = 63.898
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.353999483749, Press = -0.343338564350711
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.753 | 3.753 | 3.753 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    250000  -3632.1496     -3632.1496     -3712.2303     -3712.2303      309.92061      309.92061      41868.903      41868.903      420.28282      420.28282    
    251000  -3630.6375     -3630.6375     -3714.1281     -3714.1281      323.11732      323.11732      41990.701      41990.701      141.7996       141.7996     
Loop time of 105.193 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.16     | 104.16     | 104.16     |   0.0 | 99.02
Neigh   | 0.53917    | 0.53917    | 0.53917    |   0.0 |  0.51
Comm    | 0.092899   | 0.092899   | 0.092899   |   0.0 |  0.09
Output  | 0.00016014 | 0.00016014 | 0.00016014 |   0.0 |  0.00
Modify  | 0.34469    | 0.34469    | 0.34469    |   0.0 |  0.33
Other   |            | 0.05739    |            |       |  0.05

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

Total # of neighbors = 127476
Ave neighs/atom = 63.738
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.352774582698, Press = -0.103870567549481
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.1
  ghost atom cutoff = 7.1
  binsize = 3.55, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.1
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.752 | 3.752 | 3.752 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    251000  -3630.6375     -3630.6375     -3714.1281     -3714.1281      323.11732      323.11732      41990.701      41990.701      141.7996       141.7996     
    252000  -3636.264      -3636.264      -3716.7263     -3716.7263      311.39742      311.39742      42037.772      42037.772     -187.7586      -187.7586     
Loop time of 106.076 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.465 hours/ns, 9.427 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.06     | 105.06     | 105.06     |   0.0 | 99.04
Neigh   | 0.51879    | 0.51879    | 0.51879    |   0.0 |  0.49
Comm    | 0.092529   | 0.092529   | 0.092529   |   0.0 |  0.09
Output  | 0.00020415 | 0.00020415 | 0.00020415 |   0.0 |  0.00
Modify  | 0.34673    | 0.34673    | 0.34673    |   0.0 |  0.33
Other   |            | 0.05769    |            |       |  0.05

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0