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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 2.8809778466820717*${_u_distance}
variable latticeconst_converted equal 2.8809778466820717*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.88097784668207
Lattice spacing in x,y,z = 2.8809778 2.8809778 2.8809778
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.809778 28.809778 28.809778)
  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 (28.809778 28.809778 28.809778)
  create_atoms CPU = 0.005 seconds

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

kim_interactions Cr

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

kim interactions Cr
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_LeeShimPark_2001_FeCr__MO_150993986463_001
pair_coeff * * Cr
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 51.9961

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

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

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

variable temp_converted equal 333.15*${_u_temperature}
variable temp_converted equal 333.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

# create initial velocities consistent with the chosen temperature
velocity      all create ${temp_converted} 17 mom yes rot yes
velocity      all create 333.15 17 mom yes rot yes

# set NPT ensemble for all atoms
fix           ensemble all npt temp ${temp_converted} ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 1

# compute the time averages of pressure, temperature, and volume, respectively
# ignore the first 5000 timesteps
variable      etotal_metal equal etotal/${_u_energy}
variable      etotal_metal equal etotal/1
variable      pe_metal equal pe/${_u_energy}
variable      pe_metal equal pe/1
variable      T_metal equal temp/${_u_temperature}
variable      T_metal equal temp/1
variable      V_metal equal vol/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*1*${_u_distance})
variable      V_metal equal vol/(1*1*1)
variable      P_metal equal press/${_u_pressure}
variable      P_metal equal press/1
fix           avgmyTemp  all ave/time 5 20 100 v_T_metal  ave running start 5000
fix           avgmyPress all ave/time 5 20 100 v_P_metal ave running start 5000
fix           avgmyVol   all ave/time 5 20 100 v_V_metal   ave running start 5000

# extract fix quantities into variables so they can be used in if-else logic later.
variable      T equal f_avgmyTemp
variable      P equal f_avgmyPress
variable      V equal f_avgmyVol

# set error bounds for temperature and pressure in original metal units (K and bar)
variable      T_low equal  "333.15 - 0.2"
variable      T_up  equal  "333.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

# print to logfile every 1000 timesteps
thermo_style  custom step etotal v_etotal_metal pe v_pe_metal               temp v_T_metal vol v_V_metal press v_P_metal
thermo        1000

# Run a simulation for at most 2000*1000 timesteps. At each 1000th time step, check
# whether the temperature and pressure have converged. If yes, break.
label top
variable a loop 2000
run 1000

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

Your simulation uses code contributions which should be cited:

- OpenKIM: https://doi.org/10.1007/s11837-011-0102-6

@Article{tadmor:elliott:2011,
 author = {E. B. Tadmor and R. S. Elliott and J. P. Sethna and R. E. Miller and C. A. Becker},
 title = {The potential of atomistic simulations and the {K}nowledgebase of {I}nteratomic {M}odels},
 journal = {{JOM}},
 year =    2011,
 volume =  63,
 number =  17,
 pages =   {17},
 doi =     {10.1007/s11837-011-0102-6}
}

- OpenKIM potential: https://openkim.org/cite/MO_150993986463_001#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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  -8113.917      -8113.917      -8200          -8200           333.15         333.15         23912.212      23912.212      3845.1702      3845.1702    
      1000  -8019.8942     -8019.8942     -8110.0246     -8110.0246      348.81407      348.81407      24073.187      24073.187      3113.907       3113.907     
Loop time of 101.166 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.854 ns/day, 28.102 hours/ns, 9.885 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.65     | 100.65     | 100.65     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099429   | 0.099429   | 0.099429   |   0.0 |  0.10
Output  | 0.00021039 | 0.00021039 | 0.00021039 |   0.0 |  0.00
Modify  | 0.35324    | 0.35324    | 0.35324    |   0.0 |  0.35
Other   |            | 0.05867    |            |       |  0.06

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

Total # of neighbors = 128000
Ave neighs/atom = 64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8019.8942     -8019.8942     -8110.0246     -8110.0246      348.81407      348.81407      24073.187      24073.187      3113.907       3113.907     
      2000  -8022.5985     -8022.5985     -8104.0895     -8104.0895      315.37843      315.37843      24076.1        24076.1        2985.1545      2985.1545    
Loop time of 104.694 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.18     | 104.18     | 104.18     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098687   | 0.098687   | 0.098687   |   0.0 |  0.09
Output  | 0.00025005 | 0.00025005 | 0.00025005 |   0.0 |  0.00
Modify  | 0.35138    | 0.35138    | 0.35138    |   0.0 |  0.34
Other   |            | 0.05983    |            |       |  0.06

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

Total # of neighbors = 127962
Ave neighs/atom = 63.981
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8022.5985     -8022.5985     -8104.0895     -8104.0895      315.37843      315.37843      24076.1        24076.1        2985.1545      2985.1545    
      3000  -8021.8733     -8021.8733     -8109.8635     -8109.8635      340.53143      340.53143      24090.333      24090.333      1520.0241      1520.0241    
Loop time of 104.343 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 28.984 hours/ns, 9.584 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.83     | 103.83     | 103.83     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097927   | 0.097927   | 0.097927   |   0.0 |  0.09
Output  | 0.00020415 | 0.00020415 | 0.00020415 |   0.0 |  0.00
Modify  | 0.34964    | 0.34964    | 0.34964    |   0.0 |  0.34
Other   |            | 0.06009    |            |       |  0.06

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

Total # of neighbors = 127944
Ave neighs/atom = 63.972
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8021.8733     -8021.8733     -8109.8635     -8109.8635      340.53143      340.53143      24090.333      24090.333      1520.0241      1520.0241    
      4000  -8021.5085     -8021.5085     -8109.2049     -8109.2049      339.39397      339.39397      24096.25       24096.25       1118.5728      1118.5728    
Loop time of 104.807 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.113 hours/ns, 9.541 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.3      | 104.3      | 104.3      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098039   | 0.098039   | 0.098039   |   0.0 |  0.09
Output  | 0.00020482 | 0.00020482 | 0.00020482 |   0.0 |  0.00
Modify  | 0.35191    | 0.35191    | 0.35191    |   0.0 |  0.34
Other   |            | 0.06054    |            |       |  0.06

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

Total # of neighbors = 127936
Ave neighs/atom = 63.968
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8021.5085     -8021.5085     -8109.2049     -8109.2049      339.39397      339.39397      24096.25       24096.25       1118.5728      1118.5728    
      5000  -8022.7564     -8022.7564     -8105.0673     -8105.0673      318.55162      318.55162      24091.151      24091.151      1801.1996      1801.1996    
Loop time of 105.503 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.306 hours/ns, 9.478 timesteps/s
99.9% 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.99     | 104.99     | 104.99     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098182   | 0.098182   | 0.098182   |   0.0 |  0.09
Output  | 0.00016595 | 0.00016595 | 0.00016595 |   0.0 |  0.00
Modify  | 0.35561    | 0.35561    | 0.35561    |   0.0 |  0.34
Other   |            | 0.0603     |            |       |  0.06

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

Total # of neighbors = 127916
Ave neighs/atom = 63.958
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.951761804328, Press = 445.749326978204
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8022.7564     -8022.7564     -8105.0673     -8105.0673      318.55162      318.55162      24091.151      24091.151      1801.1996      1801.1996    
      6000  -8020.7821     -8020.7821     -8108.3159     -8108.3159      338.76482      338.76482      24089.771      24089.771      1806.4483      1806.4483    
Loop time of 106.431 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.564 hours/ns, 9.396 timesteps/s
99.9% 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.89     | 105.89     | 105.89     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098894   | 0.098894   | 0.098894   |   0.0 |  0.09
Output  | 0.00022548 | 0.00022548 | 0.00022548 |   0.0 |  0.00
Modify  | 0.38114    | 0.38114    | 0.38114    |   0.0 |  0.36
Other   |            | 0.06091    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.635288031477, Press = 89.2943177020704
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8020.7821     -8020.7821     -8108.3159     -8108.3159      338.76482      338.76482      24089.771      24089.771      1806.4483      1806.4483    
      7000  -8025.7399     -8025.7399     -8110.6859     -8110.6859      328.74954      328.74954      24105.931      24105.931      109.65554      109.65554    
Loop time of 106.064 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.462 hours/ns, 9.428 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.53     | 105.53     | 105.53     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098508   | 0.098508   | 0.098508   |   0.0 |  0.09
Output  | 0.00020714 | 0.00020714 | 0.00020714 |   0.0 |  0.00
Modify  | 0.37668    | 0.37668    | 0.37668    |   0.0 |  0.36
Other   |            | 0.06036    |            |       |  0.06

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

Total # of neighbors = 127954
Ave neighs/atom = 63.977
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.94827548579, Press = 63.1817864913378
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8025.7399     -8025.7399     -8110.6859     -8110.6859      328.74954      328.74954      24105.931      24105.931      109.65554      109.65554    
      8000  -8020.4706     -8020.4706     -8106.1401     -8106.1401      331.54987      331.54987      24118.592      24118.592     -376.91251     -376.91251    
Loop time of 107.794 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.802 ns/day, 29.943 hours/ns, 9.277 timesteps/s
99.9% 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.24     | 107.24     | 107.24     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10142    | 0.10142    | 0.10142    |   0.0 |  0.09
Output  | 0.00016986 | 0.00016986 | 0.00016986 |   0.0 |  0.00
Modify  | 0.38789    | 0.38789    | 0.38789    |   0.0 |  0.36
Other   |            | 0.06191    |            |       |  0.06

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

Total # of neighbors = 127960
Ave neighs/atom = 63.98
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.945534051158, Press = 19.9781285178751
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8020.4706     -8020.4706     -8106.1401     -8106.1401      331.54987      331.54987      24118.592      24118.592     -376.91251     -376.91251    
      9000  -8025.1243     -8025.1243     -8110.0942     -8110.0942      328.84224      328.84224      24117.376      24117.376     -742.49098     -742.49098    
Loop time of 105.702 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.362 hours/ns, 9.461 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.16     | 105.16     | 105.16     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099586   | 0.099586   | 0.099586   |   0.0 |  0.09
Output  | 0.00021726 | 0.00021726 | 0.00021726 |   0.0 |  0.00
Modify  | 0.37778    | 0.37778    | 0.37778    |   0.0 |  0.36
Other   |            | 0.06053    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127944 ave      127944 max      127944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127944
Ave neighs/atom = 63.972
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.654412325077, Press = 9.95145039210945
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8025.1243     -8025.1243     -8110.0942     -8110.0942      328.84224      328.84224      24117.376      24117.376     -742.49098     -742.49098    
     10000  -8021.2526     -8021.2526     -8105.5888     -8105.5888      326.38949      326.38949      24137.342      24137.342     -1913.0618     -1913.0618    
Loop time of 105.592 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.06     | 105.06     | 105.06     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098396   | 0.098396   | 0.098396   |   0.0 |  0.09
Output  | 0.00020463 | 0.00020463 | 0.00020463 |   0.0 |  0.00
Modify  | 0.37686    | 0.37686    | 0.37686    |   0.0 |  0.36
Other   |            | 0.05998    |            |       |  0.06

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

Total # of neighbors = 127928
Ave neighs/atom = 63.964
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.89996901183, Press = 7.42555721392664
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8021.2526     -8021.2526     -8105.5888     -8105.5888      326.38949      326.38949      24137.342      24137.342     -1913.0618     -1913.0618    
     11000  -8020.2196     -8020.2196     -8108.8871     -8108.8871      343.15253      343.15253      24147.61       24147.61      -2764.3172     -2764.3172    
Loop time of 106.194 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.498 hours/ns, 9.417 timesteps/s
99.9% 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.66     | 105.66     | 105.66     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098645   | 0.098645   | 0.098645   |   0.0 |  0.09
Output  | 0.00021535 | 0.00021535 | 0.00021535 |   0.0 |  0.00
Modify  | 0.37803    | 0.37803    | 0.37803    |   0.0 |  0.36
Other   |            | 0.06077    |            |       |  0.06

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

Total # of neighbors = 127934
Ave neighs/atom = 63.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.304500201515, Press = 2.42979585868177
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8020.2196     -8020.2196     -8108.8871     -8108.8871      343.15253      343.15253      24147.61       24147.61      -2764.3172     -2764.3172    
     12000  -8021.079      -8021.079      -8107.4848     -8107.4848      334.39945      334.39945      24142.361      24142.361     -2262.6373     -2262.6373    
Loop time of 107.541 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.803 ns/day, 29.873 hours/ns, 9.299 timesteps/s
99.9% 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        | 107        | 107        |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10084    | 0.10084    | 0.10084    |   0.0 |  0.09
Output  | 0.0001655  | 0.0001655  | 0.0001655  |   0.0 |  0.00
Modify  | 0.38381    | 0.38381    | 0.38381    |   0.0 |  0.36
Other   |            | 0.06063    |            |       |  0.06

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

Total # of neighbors = 127938
Ave neighs/atom = 63.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.946247147713, Press = -3.73799138160159
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8021.079      -8021.079      -8107.4848     -8107.4848      334.39945      334.39945      24142.361      24142.361     -2262.6373     -2262.6373    
     13000  -8021.7805     -8021.7805     -8106.4969     -8106.4969      327.86093      327.86093      24155.199      24155.199     -3248.4439     -3248.4439    
Loop time of 105.83 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.397 hours/ns, 9.449 timesteps/s
99.9% 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.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099525   | 0.099525   | 0.099525   |   0.0 |  0.09
Output  | 0.00020535 | 0.00020535 | 0.00020535 |   0.0 |  0.00
Modify  | 0.37796    | 0.37796    | 0.37796    |   0.0 |  0.36
Other   |            | 0.06049    |            |       |  0.06

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

Total # of neighbors = 127928
Ave neighs/atom = 63.964
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.923789946914, Press = -9.1279493925821
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8021.7805     -8021.7805     -8106.4969     -8106.4969      327.86093      327.86093      24155.199      24155.199     -3248.4439     -3248.4439    
     14000  -8020.9971     -8020.9971     -8107.7488     -8107.7488      335.73807      335.73807      24151.382      24151.382     -3002.6452     -3002.6452    
Loop time of 106.286 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.524 hours/ns, 9.409 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.75     | 105.75     | 105.75     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099228   | 0.099228   | 0.099228   |   0.0 |  0.09
Output  | 0.0004729  | 0.0004729  | 0.0004729  |   0.0 |  0.00
Modify  | 0.37751    | 0.37751    | 0.37751    |   0.0 |  0.36
Other   |            | 0.06077    |            |       |  0.06

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

Total # of neighbors = 127938
Ave neighs/atom = 63.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.74448571354, Press = -10.7540500748198
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8020.9971     -8020.9971     -8107.7488     -8107.7488      335.73807      335.73807      24151.382      24151.382     -3002.6452     -3002.6452    
     15000  -8022.7224     -8022.7224     -8109.456      -8109.456       335.66812      335.66812      24117.143      24117.143     -594.98198     -594.98198    
Loop time of 105.291 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.75     | 104.75     | 104.75     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098379   | 0.098379   | 0.098379   |   0.0 |  0.09
Output  | 0.00016464 | 0.00016464 | 0.00016464 |   0.0 |  0.00
Modify  | 0.37775    | 0.37775    | 0.37775    |   0.0 |  0.36
Other   |            | 0.0604     |            |       |  0.06

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

Total # of neighbors = 127926
Ave neighs/atom = 63.963
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.778085982476, Press = -5.00344589469773
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8022.7224     -8022.7224     -8109.456      -8109.456       335.66812      335.66812      24117.143      24117.143     -594.98198     -594.98198    
     16000  -8021.4747     -8021.4747     -8106.4012     -8106.4012      328.67423      328.67423      24104.519      24104.519      960.98589      960.98589    
Loop time of 107.926 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.801 ns/day, 29.979 hours/ns, 9.266 timesteps/s
99.9% 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.38     | 107.38     | 107.38     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10017    | 0.10017    | 0.10017    |   0.0 |  0.09
Output  | 0.00016716 | 0.00016716 | 0.00016716 |   0.0 |  0.00
Modify  | 0.38819    | 0.38819    | 0.38819    |   0.0 |  0.36
Other   |            | 0.06121    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.948670839055, Press = -2.71724369781883
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8021.4747     -8021.4747     -8106.4012     -8106.4012      328.67423      328.67423      24104.519      24104.519      960.98589      960.98589    
     17000  -8023.5713     -8023.5713     -8109.7356     -8109.7356      333.46465      333.46465      24094.084      24094.084      1164.0533      1164.0533    
Loop time of 107.567 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.803 ns/day, 29.880 hours/ns, 9.297 timesteps/s
99.9% 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.02     | 107.02     | 107.02     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10069    | 0.10069    | 0.10069    |   0.0 |  0.09
Output  | 0.00016661 | 0.00016661 | 0.00016661 |   0.0 |  0.00
Modify  | 0.38604    | 0.38604    | 0.38604    |   0.0 |  0.36
Other   |            | 0.06122    |            |       |  0.06

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

Total # of neighbors = 127938
Ave neighs/atom = 63.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.191672744153, Press = -2.37893004096962
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8023.5713     -8023.5713     -8109.7356     -8109.7356      333.46465      333.46465      24094.084      24094.084      1164.0533      1164.0533    
     18000  -8025.477      -8025.477      -8111.3663     -8111.3663      332.40059      332.40059      24084.296      24084.296      1685.9658      1685.9658    
Loop time of 106.686 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.635 hours/ns, 9.373 timesteps/s
99.9% 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.15     | 106.15     | 106.15     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09984    | 0.09984    | 0.09984    |   0.0 |  0.09
Output  | 0.00021526 | 0.00021526 | 0.00021526 |   0.0 |  0.00
Modify  | 0.37985    | 0.37985    | 0.37985    |   0.0 |  0.36
Other   |            | 0.06079    |            |       |  0.06

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

Total # of neighbors = 127934
Ave neighs/atom = 63.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.16170200034, Press = -1.69895361973667
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8025.477      -8025.477      -8111.3663     -8111.3663      332.40059      332.40059      24084.296      24084.296      1685.9658      1685.9658    
     19000  -8019.6736     -8019.6736     -8106.0072     -8106.0072      334.12007      334.12007      24058.79       24058.79       4382.3055      4382.3055    
Loop time of 107.742 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.802 ns/day, 29.928 hours/ns, 9.281 timesteps/s
99.9% 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.19     | 107.19     | 107.19     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099651   | 0.099651   | 0.099651   |   0.0 |  0.09
Output  | 0.00016713 | 0.00016713 | 0.00016713 |   0.0 |  0.00
Modify  | 0.38767    | 0.38767    | 0.38767    |   0.0 |  0.36
Other   |            | 0.06153    |            |       |  0.06

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

Total # of neighbors = 127934
Ave neighs/atom = 63.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.074370233041, Press = -3.09994156396585
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8019.6736     -8019.6736     -8106.0072     -8106.0072      334.12007      334.12007      24058.79       24058.79       4382.3055      4382.3055    
     20000  -8026.9397     -8026.9397     -8111.9937     -8111.9937      329.1676       329.1676       24060.42       24060.42       3315.9393      3315.9393    
Loop time of 107.98 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.800 ns/day, 29.994 hours/ns, 9.261 timesteps/s
99.9% 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.43     | 107.43     | 107.43     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099963   | 0.099963   | 0.099963   |   0.0 |  0.09
Output  | 0.00021128 | 0.00021128 | 0.00021128 |   0.0 |  0.00
Modify  | 0.38909    | 0.38909    | 0.38909    |   0.0 |  0.36
Other   |            | 0.06184    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.019298157482, Press = 0.326638662010546
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8026.9397     -8026.9397     -8111.9937     -8111.9937      329.1676       329.1676       24060.42       24060.42       3315.9393      3315.9393    
     21000  -8020.4763     -8020.4763     -8107.0661     -8107.0661      335.11162      335.11162      24087.917      24087.917      1945.8309      1945.8309    
Loop time of 105.781 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.384 hours/ns, 9.454 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.25     | 105.25     | 105.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098514   | 0.098514   | 0.098514   |   0.0 |  0.09
Output  | 0.00016829 | 0.00016829 | 0.00016829 |   0.0 |  0.00
Modify  | 0.37613    | 0.37613    | 0.37613    |   0.0 |  0.36
Other   |            | 0.05984    |            |       |  0.06

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

Total # of neighbors = 127954
Ave neighs/atom = 63.977
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.961257483444, Press = 2.00882329294426
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8020.4763     -8020.4763     -8107.0661     -8107.0661      335.11162      335.11162      24087.917      24087.917      1945.8309      1945.8309    
     22000  -8024.1414     -8024.1414     -8111.2923     -8111.2923      337.28318      337.28318      24081.384      24081.384      1998.7471      1998.7471    
Loop time of 108.474 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.797 ns/day, 30.132 hours/ns, 9.219 timesteps/s
99.9% 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.92     | 107.92     | 107.92     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10128    | 0.10128    | 0.10128    |   0.0 |  0.09
Output  | 0.00016589 | 0.00016589 | 0.00016589 |   0.0 |  0.00
Modify  | 0.39258    | 0.39258    | 0.39258    |   0.0 |  0.36
Other   |            | 0.06146    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127950 ave      127950 max      127950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127950
Ave neighs/atom = 63.975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.901410026216, Press = 2.71447282721646
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8024.1414     -8024.1414     -8111.2923     -8111.2923      337.28318      337.28318      24081.384      24081.384      1998.7471      1998.7471    
     23000  -8022.0198     -8022.0198     -8109.0678     -8109.0678      336.88471      336.88471      24084.691      24084.691      2039.4195      2039.4195    
Loop time of 104.562 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.03     | 104.03     | 104.03     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097624   | 0.097624   | 0.097624   |   0.0 |  0.09
Output  | 0.00020339 | 0.00020339 | 0.00020339 |   0.0 |  0.00
Modify  | 0.37255    | 0.37255    | 0.37255    |   0.0 |  0.36
Other   |            | 0.05982    |            |       |  0.06

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

Total # of neighbors = 127938
Ave neighs/atom = 63.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.907578500877, Press = 3.61743831059698
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8022.0198     -8022.0198     -8109.0678     -8109.0678      336.88471      336.88471      24084.691      24084.691      2039.4195      2039.4195    
     24000  -8021.5044     -8021.5044     -8106.9362     -8106.9362      330.62985      330.62985      24096.68       24096.68       1232.2902      1232.2902    
Loop time of 105.451 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.92     | 104.92     | 104.92     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097478   | 0.097478   | 0.097478   |   0.0 |  0.09
Output  | 0.00016651 | 0.00016651 | 0.00016651 |   0.0 |  0.00
Modify  | 0.37385    | 0.37385    | 0.37385    |   0.0 |  0.35
Other   |            | 0.05984    |            |       |  0.06

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

Total # of neighbors = 127936
Ave neighs/atom = 63.968
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.754345646972, Press = 4.87408319770094
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8021.5044     -8021.5044     -8106.9362     -8106.9362      330.62985      330.62985      24096.68       24096.68       1232.2902      1232.2902    
     25000  -8024.6996     -8024.6996     -8108.7328     -8108.7328      325.21719      325.21719      24104.052      24104.052      448.621        448.621      
Loop time of 104.636 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.1      | 104.1      | 104.1      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098195   | 0.098195   | 0.098195   |   0.0 |  0.09
Output  | 0.00016648 | 0.00016648 | 0.00016648 |   0.0 |  0.00
Modify  | 0.37251    | 0.37251    | 0.37251    |   0.0 |  0.36
Other   |            | 0.06046    |            |       |  0.06

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

Total # of neighbors = 127960
Ave neighs/atom = 63.98
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.740505869151, Press = 6.17787390203868
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8024.6996     -8024.6996     -8108.7328     -8108.7328      325.21719      325.21719      24104.052      24104.052      448.621        448.621      
     26000  -8021.8219     -8021.8219     -8107.7098     -8107.7098      332.39491      332.39491      24127.65       24127.65      -1232.6636     -1232.6636    
Loop time of 106.346 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.81     | 105.81     | 105.81     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099144   | 0.099144   | 0.099144   |   0.0 |  0.09
Output  | 0.00016611 | 0.00016611 | 0.00016611 |   0.0 |  0.00
Modify  | 0.37847    | 0.37847    | 0.37847    |   0.0 |  0.36
Other   |            | 0.06048    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127968 ave      127968 max      127968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127968
Ave neighs/atom = 63.984
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.747754731114, Press = 6.31568689827325
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8021.8219     -8021.8219     -8107.7098     -8107.7098      332.39491      332.39491      24127.65       24127.65      -1232.6636     -1232.6636    
     27000  -8028.7214     -8028.7214     -8111.8033     -8111.8033      321.53581      321.53581      24121.823      24121.823     -1358.8234     -1358.8234    
Loop time of 105.449 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.91     | 104.91     | 104.91     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098543   | 0.098543   | 0.098543   |   0.0 |  0.09
Output  | 0.00016271 | 0.00016271 | 0.00016271 |   0.0 |  0.00
Modify  | 0.37535    | 0.37535    | 0.37535    |   0.0 |  0.36
Other   |            | 0.06026    |            |       |  0.06

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

Total # of neighbors = 127936
Ave neighs/atom = 63.968
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.701308234516, Press = 2.95525383556828
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8028.7214     -8028.7214     -8111.8033     -8111.8033      321.53581      321.53581      24121.823      24121.823     -1358.8234     -1358.8234    
     28000  -8021.97       -8021.97       -8108.438      -8108.438       334.63999      334.63999      24132.157      24132.157     -1646.588      -1646.588     
Loop time of 106.266 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.518 hours/ns, 9.410 timesteps/s
99.9% 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.73     | 105.73     | 105.73     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099237   | 0.099237   | 0.099237   |   0.0 |  0.09
Output  | 0.00021177 | 0.00021177 | 0.00021177 |   0.0 |  0.00
Modify  | 0.37599    | 0.37599    | 0.37599    |   0.0 |  0.35
Other   |            | 0.06036    |            |       |  0.06

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

Total # of neighbors = 127954
Ave neighs/atom = 63.977
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.558169132682, Press = 1.73221408633287
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8021.97       -8021.97       -8108.438      -8108.438       334.63999      334.63999      24132.157      24132.157     -1646.588      -1646.588     
     29000  -8022.8881     -8022.8881     -8107.8827     -8107.8827      328.93823      328.93823      24131.879      24131.879     -1524.1479     -1524.1479    
Loop time of 106.698 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.638 hours/ns, 9.372 timesteps/s
99.9% 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.15     | 106.15     | 106.15     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1003     | 0.1003     | 0.1003     |   0.0 |  0.09
Output  | 0.00016653 | 0.00016653 | 0.00016653 |   0.0 |  0.00
Modify  | 0.38449    | 0.38449    | 0.38449    |   0.0 |  0.36
Other   |            | 0.06084    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.56483827522, Press = 1.16361499438819
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8022.8881     -8022.8881     -8107.8827     -8107.8827      328.93823      328.93823      24131.879      24131.879     -1524.1479     -1524.1479    
     30000  -8023.702      -8023.702      -8109.2077     -8109.2077      330.91617      330.91617      24145.563      24145.563     -2778.4116     -2778.4116    
Loop time of 105.029 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.5      | 104.5      | 104.5      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098568   | 0.098568   | 0.098568   |   0.0 |  0.09
Output  | 0.00016555 | 0.00016555 | 0.00016555 |   0.0 |  0.00
Modify  | 0.37395    | 0.37395    | 0.37395    |   0.0 |  0.36
Other   |            | 0.06005    |            |       |  0.06

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

Total # of neighbors = 127944
Ave neighs/atom = 63.972
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.419554306583, Press = 0.437330657306674
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8023.702      -8023.702      -8109.2077     -8109.2077      330.91617      330.91617      24145.563      24145.563     -2778.4116     -2778.4116    
     31000  -8021.7524     -8021.7524     -8107.6628     -8107.6628      332.48216      332.48216      24172.507      24172.507     -4576.3589     -4576.3589    
Loop time of 105.133 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.6      | 104.6      | 104.6      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098362   | 0.098362   | 0.098362   |   0.0 |  0.09
Output  | 0.00016573 | 0.00016573 | 0.00016573 |   0.0 |  0.00
Modify  | 0.37552    | 0.37552    | 0.37552    |   0.0 |  0.36
Other   |            | 0.06087    |            |       |  0.06

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

Total # of neighbors = 127928
Ave neighs/atom = 63.964
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.423118200953, Press = -1.15542297547019
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8021.7524     -8021.7524     -8107.6628     -8107.6628      332.48216      332.48216      24172.507      24172.507     -4576.3589     -4576.3589    
     32000  -8025.4222     -8025.4222     -8110.231      -8110.231       328.21858      328.21858      24142.557      24142.557     -2623.8385     -2623.8385    
Loop time of 105.803 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.390 hours/ns, 9.452 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.27     | 105.27     | 105.27     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09889    | 0.09889    | 0.09889    |   0.0 |  0.09
Output  | 0.00016628 | 0.00016628 | 0.00016628 |   0.0 |  0.00
Modify  | 0.37615    | 0.37615    | 0.37615    |   0.0 |  0.36
Other   |            | 0.06003    |            |       |  0.06

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

Total # of neighbors = 127912
Ave neighs/atom = 63.956
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.308659144568, Press = -0.994593419567165
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8025.4222     -8025.4222     -8110.231      -8110.231       328.21858      328.21858      24142.557      24142.557     -2623.8385     -2623.8385    
     33000  -8021.5245     -8021.5245     -8107.3613     -8107.3613      332.19752      332.19752      24125.954      24125.954     -946.13359     -946.13359    
Loop time of 106.319 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.533 hours/ns, 9.406 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.78     | 105.78     | 105.78     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098611   | 0.098611   | 0.098611   |   0.0 |  0.09
Output  | 0.00020465 | 0.00020465 | 0.00020465 |   0.0 |  0.00
Modify  | 0.37737    | 0.37737    | 0.37737    |   0.0 |  0.35
Other   |            | 0.06049    |            |       |  0.06

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

Total # of neighbors = 127926
Ave neighs/atom = 63.963
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.245699488973, Press = -0.709795743922316
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8021.5245     -8021.5245     -8107.3613     -8107.3613      332.19752      332.19752      24125.954      24125.954     -946.13359     -946.13359    
     34000  -8024.3635     -8024.3635     -8110.8813     -8110.8813      334.83295      334.83295      24117.002      24117.002     -720.35811     -720.35811    
Loop time of 105.344 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.262 hours/ns, 9.493 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.81     | 104.81     | 104.81     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097251   | 0.097251   | 0.097251   |   0.0 |  0.09
Output  | 0.00016743 | 0.00016743 | 0.00016743 |   0.0 |  0.00
Modify  | 0.37396    | 0.37396    | 0.37396    |   0.0 |  0.35
Other   |            | 0.06034    |            |       |  0.06

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

Total # of neighbors = 127944
Ave neighs/atom = 63.972
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.27324965953, Press = -0.838622873564146
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8024.3635     -8024.3635     -8110.8813     -8110.8813      334.83295      334.83295      24117.002      24117.002     -720.35811     -720.35811    
     35000  -8020.8999     -8020.8999     -8107.1762     -8107.1762      333.89792      333.89792      24112.361      24112.361      146.32726      146.32726    
Loop time of 105.952 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.431 hours/ns, 9.438 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.41     | 105.41     | 105.41     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098974   | 0.098974   | 0.098974   |   0.0 |  0.09
Output  | 0.0001684  | 0.0001684  | 0.0001684  |   0.0 |  0.00
Modify  | 0.37784    | 0.37784    | 0.37784    |   0.0 |  0.36
Other   |            | 0.06064    |            |       |  0.06

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

Total # of neighbors = 127946
Ave neighs/atom = 63.973
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.304099521883, Press = -1.52438552202174
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8020.8999     -8020.8999     -8107.1762     -8107.1762      333.89792      333.89792      24112.361      24112.361      146.32726      146.32726    
     36000  -8026.1896     -8026.1896     -8111.7144     -8111.7144      330.98989      330.98989      24083.966      24083.966      1687.5398      1687.5398    
Loop time of 105.397 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.277 hours/ns, 9.488 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.86     | 104.86     | 104.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098584   | 0.098584   | 0.098584   |   0.0 |  0.09
Output  | 0.00016624 | 0.00016624 | 0.00016624 |   0.0 |  0.00
Modify  | 0.37514    | 0.37514    | 0.37514    |   0.0 |  0.36
Other   |            | 0.06032    |            |       |  0.06

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

Total # of neighbors = 127926
Ave neighs/atom = 63.963
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.269862137098, Press = -3.42048055308792
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8026.1896     -8026.1896     -8111.7144     -8111.7144      330.98989      330.98989      24083.966      24083.966      1687.5398      1687.5398    
     37000  -8020.9728     -8020.9728     -8107.7686     -8107.7686      335.90882      335.90882      24078.267      24078.267      2769.098       2769.098     
Loop time of 107.495 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.860 hours/ns, 9.303 timesteps/s
99.9% 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.95     | 106.95     | 106.95     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099993   | 0.099993   | 0.099993   |   0.0 |  0.09
Output  | 0.0002493  | 0.0002493  | 0.0002493  |   0.0 |  0.00
Modify  | 0.38793    | 0.38793    | 0.38793    |   0.0 |  0.36
Other   |            | 0.06061    |            |       |  0.06

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

Total # of neighbors = 127952
Ave neighs/atom = 63.976
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.222705198699, Press = -1.35905742470447
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8020.9728     -8020.9728     -8107.7686     -8107.7686      335.90882      335.90882      24078.267      24078.267      2769.098       2769.098     
     38000  -8024.3366     -8024.3366     -8110.5762     -8110.5762      333.75601      333.75601      24089.178      24089.178      1343.885       1343.885     
Loop time of 106.66 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.628 hours/ns, 9.376 timesteps/s
99.9% 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.12     | 106.12     | 106.12     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099422   | 0.099422   | 0.099422   |   0.0 |  0.09
Output  | 0.00016462 | 0.00016462 | 0.00016462 |   0.0 |  0.00
Modify  | 0.38164    | 0.38164    | 0.38164    |   0.0 |  0.36
Other   |            | 0.0606     |            |       |  0.06

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

Total # of neighbors = 127956
Ave neighs/atom = 63.978
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.209249516585, Press = 0.548568753207139
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8024.3366     -8024.3366     -8110.5762     -8110.5762      333.75601      333.75601      24089.178      24089.178      1343.885       1343.885     
     39000  -8018.9957     -8018.9957     -8107.5364     -8107.5364      342.66137      342.66137      24098.465      24098.465      1287.6971      1287.6971    
Loop time of 106.764 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.657 hours/ns, 9.366 timesteps/s
99.9% 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.22     | 106.22     | 106.22     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099      | 0.099      | 0.099      |   0.0 |  0.09
Output  | 0.00016283 | 0.00016283 | 0.00016283 |   0.0 |  0.00
Modify  | 0.38213    | 0.38213    | 0.38213    |   0.0 |  0.36
Other   |            | 0.06084    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127930 ave      127930 max      127930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127930
Ave neighs/atom = 63.965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.177568957476, Press = 0.996327257312418
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8018.9957     -8018.9957     -8107.5364     -8107.5364      342.66137      342.66137      24098.465      24098.465      1287.6971      1287.6971    
     40000  -8023.5587     -8023.5587     -8108.052      -8108.052       326.99776      326.99776      24089.302      24089.302      1687.9712      1687.9712    
Loop time of 106.618 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.07     | 106.07     | 106.07     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099804   | 0.099804   | 0.099804   |   0.0 |  0.09
Output  | 0.00016534 | 0.00016534 | 0.00016534 |   0.0 |  0.00
Modify  | 0.38332    | 0.38332    | 0.38332    |   0.0 |  0.36
Other   |            | 0.061      |            |       |  0.06

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

Total # of neighbors = 127950
Ave neighs/atom = 63.975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.171957832226, Press = 1.50437656033914
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8023.5587     -8023.5587     -8108.052      -8108.052       326.99776      326.99776      24089.302      24089.302      1687.9712      1687.9712    
     41000  -8022.0994     -8022.0994     -8106.5961     -8106.5961      327.01117      327.01117      24066.917      24066.917      3665.7541      3665.7541    
Loop time of 107.325 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.805 ns/day, 29.813 hours/ns, 9.317 timesteps/s
99.9% 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.78     | 106.78     | 106.78     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1004     | 0.1004     | 0.1004     |   0.0 |  0.09
Output  | 0.00016589 | 0.00016589 | 0.00016589 |   0.0 |  0.00
Modify  | 0.3843     | 0.3843     | 0.3843     |   0.0 |  0.36
Other   |            | 0.06097    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127930 ave      127930 max      127930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127930
Ave neighs/atom = 63.965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.225913308897, Press = 2.43140145566117
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8022.0994     -8022.0994     -8106.5961     -8106.5961      327.01117      327.01117      24066.917      24066.917      3665.7541      3665.7541    
     42000  -8020.9493     -8020.9493     -8107.1257     -8107.1257      333.51154      333.51154      24075.319      24075.319      2865.3259      2865.3259    
Loop time of 106.441 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.9      | 105.9      | 105.9      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099092   | 0.099092   | 0.099092   |   0.0 |  0.09
Output  | 0.00016518 | 0.00016518 | 0.00016518 |   0.0 |  0.00
Modify  | 0.37999    | 0.37999    | 0.37999    |   0.0 |  0.36
Other   |            | 0.06113    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127956 ave      127956 max      127956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127956
Ave neighs/atom = 63.978
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.175480108136, Press = 3.28691697062967
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8020.9493     -8020.9493     -8107.1257     -8107.1257      333.51154      333.51154      24075.319      24075.319      2865.3259      2865.3259    
     43000  -8020.9442     -8020.9442     -8109.0505     -8109.0505      340.98052      340.98052      24094.715      24094.715      1179.7356      1179.7356    
Loop time of 106.468 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.574 hours/ns, 9.393 timesteps/s
99.9% 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.92     | 105.92     | 105.92     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099471   | 0.099471   | 0.099471   |   0.0 |  0.09
Output  | 0.00016505 | 0.00016505 | 0.00016505 |   0.0 |  0.00
Modify  | 0.38267    | 0.38267    | 0.38267    |   0.0 |  0.36
Other   |            | 0.06074    |            |       |  0.06

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

Total # of neighbors = 127962
Ave neighs/atom = 63.981
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.167641758003, Press = 2.67616432172537
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8020.9442     -8020.9442     -8109.0505     -8109.0505      340.98052      340.98052      24094.715      24094.715      1179.7356      1179.7356    
     44000  -8017.214      -8017.214      -8105.9738     -8105.9738      343.50948      343.50948      24114.553      24114.553      213.76426      213.76426    
Loop time of 107.269 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.805 ns/day, 29.797 hours/ns, 9.322 timesteps/s
99.9% 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.72     | 106.72     | 106.72     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10005    | 0.10005    | 0.10005    |   0.0 |  0.09
Output  | 0.00020526 | 0.00020526 | 0.00020526 |   0.0 |  0.00
Modify  | 0.3858     | 0.3858     | 0.3858     |   0.0 |  0.36
Other   |            | 0.06087    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.19661216981, Press = 2.63550977262568
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8017.214      -8017.214      -8105.9738     -8105.9738      343.50948      343.50948      24114.553      24114.553      213.76426      213.76426    
     45000  -8022.6145     -8022.6145     -8108.0414     -8108.0414      330.6109       330.6109       24113.293      24113.293     -174.64248     -174.64248    
Loop time of 106.116 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.477 hours/ns, 9.424 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.58     | 105.58     | 105.58     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098276   | 0.098276   | 0.098276   |   0.0 |  0.09
Output  | 0.00016568 | 0.00016568 | 0.00016568 |   0.0 |  0.00
Modify  | 0.37798    | 0.37798    | 0.37798    |   0.0 |  0.36
Other   |            | 0.06087    |            |       |  0.06

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

Total # of neighbors = 127942
Ave neighs/atom = 63.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.279641427521, Press = 2.11939337601106
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8022.6145     -8022.6145     -8108.0414     -8108.0414      330.6109       330.6109       24113.293      24113.293     -174.64248     -174.64248    
     46000  -8015.2674     -8015.2674     -8103.1896     -8103.1896      340.26809      340.26809      24129.054      24129.054     -599.5673      -599.5673     
Loop time of 105.313 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.254 hours/ns, 9.495 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.78     | 104.78     | 104.78     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098275   | 0.098275   | 0.098275   |   0.0 |  0.09
Output  | 0.00016839 | 0.00016839 | 0.00016839 |   0.0 |  0.00
Modify  | 0.37576    | 0.37576    | 0.37576    |   0.0 |  0.36
Other   |            | 0.06052    |            |       |  0.06

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

Total # of neighbors = 127962
Ave neighs/atom = 63.981
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.338547159273, Press = 1.19319706613248
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8015.2674     -8015.2674     -8103.1896     -8103.1896      340.26809      340.26809      24129.054      24129.054     -599.5673      -599.5673     
     47000  -8023.2741     -8023.2741     -8107.987      -8107.987       327.84755      327.84755      24112.359      24112.359      3.2860658      3.2860658    
Loop time of 107.014 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.807 ns/day, 29.726 hours/ns, 9.345 timesteps/s
99.9% 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.47     | 106.47     | 106.47     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098865   | 0.098865   | 0.098865   |   0.0 |  0.09
Output  | 0.00022337 | 0.00022337 | 0.00022337 |   0.0 |  0.00
Modify  | 0.38326    | 0.38326    | 0.38326    |   0.0 |  0.36
Other   |            | 0.06081    |            |       |  0.06

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

Total # of neighbors = 127926
Ave neighs/atom = 63.963
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.417495535151, Press = 0.78187008275283
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8023.2741     -8023.2741     -8107.987      -8107.987       327.84755      327.84755      24112.359      24112.359      3.2860658      3.2860658    
     48000  -8021.1345     -8021.1345     -8107.1828     -8107.1828      333.0159       333.0159       24117.115      24117.115     -162.62005     -162.62005    
Loop time of 106.994 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.721 hours/ns, 9.346 timesteps/s
99.9% 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.45     | 106.45     | 106.45     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09968    | 0.09968    | 0.09968    |   0.0 |  0.09
Output  | 0.00016495 | 0.00016495 | 0.00016495 |   0.0 |  0.00
Modify  | 0.38065    | 0.38065    | 0.38065    |   0.0 |  0.36
Other   |            | 0.06053    |            |       |  0.06

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

Total # of neighbors = 127910
Ave neighs/atom = 63.955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.469047956155, Press = 0.859447229342421
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8021.1345     -8021.1345     -8107.1828     -8107.1828      333.0159       333.0159       24117.115      24117.115     -162.62005     -162.62005    
     49000  -8024.9703     -8024.9703     -8108.7406     -8108.7406      324.19962      324.19962      24116.012      24116.012     -499.01408     -499.01408    
Loop time of 106.125 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.479 hours/ns, 9.423 timesteps/s
99.9% 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.58     | 105.58     | 105.58     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099399   | 0.099399   | 0.099399   |   0.0 |  0.09
Output  | 0.00016554 | 0.00016554 | 0.00016554 |   0.0 |  0.00
Modify  | 0.38195    | 0.38195    | 0.38195    |   0.0 |  0.36
Other   |            | 0.06081    |            |       |  0.06

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

Total # of neighbors = 127942
Ave neighs/atom = 63.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.519503238346, Press = 0.514455059836298
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8024.9703     -8024.9703     -8108.7406     -8108.7406      324.19962      324.19962      24116.012      24116.012     -499.01408     -499.01408    
     50000  -8021.2278     -8021.2278     -8106.3034     -8106.3034      329.25124      329.25124      24125.569      24125.569     -765.18173     -765.18173    
Loop time of 106.77 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.658 hours/ns, 9.366 timesteps/s
99.9% 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.23     | 106.23     | 106.23     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09956    | 0.09956    | 0.09956    |   0.0 |  0.09
Output  | 0.0001648  | 0.0001648  | 0.0001648  |   0.0 |  0.00
Modify  | 0.38316    | 0.38316    | 0.38316    |   0.0 |  0.36
Other   |            | 0.06074    |            |       |  0.06

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

Total # of neighbors = 127962
Ave neighs/atom = 63.981
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.517811126721, Press = -0.349820212753
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8021.2278     -8021.2278     -8106.3034     -8106.3034      329.25124      329.25124      24125.569      24125.569     -765.18173     -765.18173    
     51000  -8019.5118     -8019.5118     -8105.5502     -8105.5502      332.97771      332.97771      24119.746      24119.746     -255.1814      -255.1814     
Loop time of 107.65 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.803 ns/day, 29.903 hours/ns, 9.289 timesteps/s
99.9% 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.1      | 107.1      | 107.1      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099799   | 0.099799   | 0.099799   |   0.0 |  0.09
Output  | 0.00016485 | 0.00016485 | 0.00016485 |   0.0 |  0.00
Modify  | 0.38784    | 0.38784    | 0.38784    |   0.0 |  0.36
Other   |            | 0.06148    |            |       |  0.06

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

Total # of neighbors = 127924
Ave neighs/atom = 63.962
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.526670819677, Press = -0.726072650205656
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -8019.5118     -8019.5118     -8105.5502     -8105.5502      332.97771      332.97771      24119.746      24119.746     -255.1814      -255.1814     
     52000  -8022.1933     -8022.1933     -8108.9007     -8108.9007      335.56666      335.56666      24103.697      24103.697      435.19714      435.19714    
Loop time of 107.107 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.807 ns/day, 29.752 hours/ns, 9.336 timesteps/s
99.9% 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.56     | 106.56     | 106.56     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10037    | 0.10037    | 0.10037    |   0.0 |  0.09
Output  | 0.00043043 | 0.00043043 | 0.00043043 |   0.0 |  0.00
Modify  | 0.38482    | 0.38482    | 0.38482    |   0.0 |  0.36
Other   |            | 0.06066    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.551292101266, Press = -1.25355666197971
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -8022.1933     -8022.1933     -8108.9007     -8108.9007      335.56666      335.56666      24103.697      24103.697      435.19714      435.19714    
     53000  -8019.85       -8019.85       -8106.473      -8106.473       335.23964      335.23964      24088.502      24088.502      2053.0531      2053.0531    
Loop time of 105.711 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.364 hours/ns, 9.460 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.17     | 105.17     | 105.17     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098594   | 0.098594   | 0.098594   |   0.0 |  0.09
Output  | 0.00016594 | 0.00016594 | 0.00016594 |   0.0 |  0.00
Modify  | 0.37771    | 0.37771    | 0.37771    |   0.0 |  0.36
Other   |            | 0.06019    |            |       |  0.06

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

Total # of neighbors = 127942
Ave neighs/atom = 63.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.558386783377, Press = -1.05744748141585
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -8019.85       -8019.85       -8106.473      -8106.473       335.23964      335.23964      24088.502      24088.502      2053.0531      2053.0531    
     54000  -8023.8615     -8023.8615     -8108.6608     -8108.6608      328.18187      328.18187      24091.739      24091.739      1458.4364      1458.4364    
Loop time of 107.689 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.802 ns/day, 29.914 hours/ns, 9.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    | 107.14     | 107.14     | 107.14     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099303   | 0.099303   | 0.099303   |   0.0 |  0.09
Output  | 0.00016532 | 0.00016532 | 0.00016532 |   0.0 |  0.00
Modify  | 0.38647    | 0.38647    | 0.38647    |   0.0 |  0.36
Other   |            | 0.06085    |            |       |  0.06

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

Total # of neighbors = 127942
Ave neighs/atom = 63.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.527700340103, Press = 0.0906313969101493
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -8023.8615     -8023.8615     -8108.6608     -8108.6608      328.18187      328.18187      24091.739      24091.739      1458.4364      1458.4364    
     55000  -8021.5904     -8021.5904     -8106.4736     -8106.4736      328.5067       328.5067       24095.347      24095.347      1553.0219      1553.0219    
Loop time of 104.831 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.120 hours/ns, 9.539 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.3      | 104.3      | 104.3      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097372   | 0.097372   | 0.097372   |   0.0 |  0.09
Output  | 0.00020682 | 0.00020682 | 0.00020682 |   0.0 |  0.00
Modify  | 0.3726     | 0.3726     | 0.3726     |   0.0 |  0.36
Other   |            | 0.05967    |            |       |  0.06

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

Total # of neighbors = 127934
Ave neighs/atom = 63.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.508956561584, Press = 0.41450900492262
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -8021.5904     -8021.5904     -8106.4736     -8106.4736      328.5067       328.5067       24095.347      24095.347      1553.0219      1553.0219    
     56000  -8019.8705     -8019.8705     -8106.0086     -8106.0086      333.36327      333.36327      24103.995      24103.995      923.76908      923.76908    
Loop time of 105.892 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.415 hours/ns, 9.444 timesteps/s
99.9% 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.36     | 105.36     | 105.36     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099129   | 0.099129   | 0.099129   |   0.0 |  0.09
Output  | 0.00020087 | 0.00020087 | 0.00020087 |   0.0 |  0.00
Modify  | 0.37548    | 0.37548    | 0.37548    |   0.0 |  0.35
Other   |            | 0.06047    |            |       |  0.06

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

Total # of neighbors = 127928
Ave neighs/atom = 63.964
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.472473034742, Press = 0.772152597810444
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -8019.8705     -8019.8705     -8106.0086     -8106.0086      333.36327      333.36327      24103.995      24103.995      923.76908      923.76908    
     57000  -8023.1359     -8023.1359     -8109.2977     -8109.2977      333.45512      333.45512      24084.707      24084.707      1923.7114      1923.7114    
Loop time of 107.423 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.840 hours/ns, 9.309 timesteps/s
99.9% 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.88     | 106.88     | 106.88     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099801   | 0.099801   | 0.099801   |   0.0 |  0.09
Output  | 0.0001636  | 0.0001636  | 0.0001636  |   0.0 |  0.00
Modify  | 0.38436    | 0.38436    | 0.38436    |   0.0 |  0.36
Other   |            | 0.06114    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127936 ave      127936 max      127936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127936
Ave neighs/atom = 63.968
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.490561064032, Press = 1.20055557742263
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -8023.1359     -8023.1359     -8109.2977     -8109.2977      333.45512      333.45512      24084.707      24084.707      1923.7114      1923.7114    
     58000  -8019.5561     -8019.5561     -8107.6735     -8107.6735      341.02317      341.02317      24072.903      24072.903      3021.3503      3021.3503    
Loop time of 105.859 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.405 hours/ns, 9.447 timesteps/s
99.9% 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.32     | 105.32     | 105.32     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099838   | 0.099838   | 0.099838   |   0.0 |  0.09
Output  | 0.00016476 | 0.00016476 | 0.00016476 |   0.0 |  0.00
Modify  | 0.37552    | 0.37552    | 0.37552    |   0.0 |  0.35
Other   |            | 0.06063    |            |       |  0.06

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

Total # of neighbors = 127944
Ave neighs/atom = 63.972
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.512060411176, Press = 2.09219761362636
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -8019.5561     -8019.5561     -8107.6735     -8107.6735      341.02317      341.02317      24072.903      24072.903      3021.3503      3021.3503    
     59000  -8022.097      -8022.097      -8109.2436     -8109.2436      337.26656      337.26656      24091.915      24091.915      1443.4533      1443.4533    
Loop time of 106.28 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.522 hours/ns, 9.409 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.75     | 105.75     | 105.75     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097898   | 0.097898   | 0.097898   |   0.0 |  0.09
Output  | 0.00017465 | 0.00017465 | 0.00017465 |   0.0 |  0.00
Modify  | 0.37593    | 0.37593    | 0.37593    |   0.0 |  0.35
Other   |            | 0.06052    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127946 ave      127946 max      127946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127946
Ave neighs/atom = 63.973
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.501414383995, Press = 2.16426631886996
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -8022.097      -8022.097      -8109.2436     -8109.2436      337.26656      337.26656      24091.915      24091.915      1443.4533      1443.4533    
     60000  -8017.7956     -8017.7956     -8106.5871     -8106.5871      343.63231      343.63231      24115.642      24115.642     -21.011284     -21.011284    
Loop time of 106.927 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.702 hours/ns, 9.352 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.38     | 106.38     | 106.38     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09957    | 0.09957    | 0.09957    |   0.0 |  0.09
Output  | 0.00016813 | 0.00016813 | 0.00016813 |   0.0 |  0.00
Modify  | 0.38183    | 0.38183    | 0.38183    |   0.0 |  0.36
Other   |            | 0.0607     |            |       |  0.06

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

Total # of neighbors = 127948
Ave neighs/atom = 63.974
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.548255961996, Press = 1.74010726179085
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -8017.7956     -8017.7956     -8106.5871     -8106.5871      343.63231      343.63231      24115.642      24115.642     -21.011284     -21.011284    
     61000  -8022.9464     -8022.9464     -8106.0313     -8106.0313      321.54692      321.54692      24116.029      24116.029     -160.57938     -160.57938    
Loop time of 105.868 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.408 hours/ns, 9.446 timesteps/s
99.9% 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.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098304   | 0.098304   | 0.098304   |   0.0 |  0.09
Output  | 0.00022786 | 0.00022786 | 0.00022786 |   0.0 |  0.00
Modify  | 0.37772    | 0.37772    | 0.37772    |   0.0 |  0.36
Other   |            | 0.06065    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127928 ave      127928 max      127928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127928
Ave neighs/atom = 63.964
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.579462593049, Press = 1.29081968441814
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -8022.9464     -8022.9464     -8106.0313     -8106.0313      321.54692      321.54692      24116.029      24116.029     -160.57938     -160.57938    
     62000  -8021.429      -8021.429      -8106.679      -8106.679       329.92599      329.92599      24120.469      24120.469     -468.94831     -468.94831    
Loop time of 105.336 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.260 hours/ns, 9.493 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.8      | 104.8      | 104.8      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098145   | 0.098145   | 0.098145   |   0.0 |  0.09
Output  | 0.00016961 | 0.00016961 | 0.00016961 |   0.0 |  0.00
Modify  | 0.37329    | 0.37329    | 0.37329    |   0.0 |  0.35
Other   |            | 0.06003    |            |       |  0.06

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

Total # of neighbors = 127938
Ave neighs/atom = 63.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.587281667098, Press = 0.975332157428353
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -8021.429      -8021.429      -8106.679      -8106.679       329.92599      329.92599      24120.469      24120.469     -468.94831     -468.94831    
     63000  -8025.8385     -8025.8385     -8109.74       -8109.74        324.70733      324.70733      24121.11       24121.11      -973.03608     -973.03608    
Loop time of 105.888 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.413 hours/ns, 9.444 timesteps/s
99.9% 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.35     | 105.35     | 105.35     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099116   | 0.099116   | 0.099116   |   0.0 |  0.09
Output  | 0.00020838 | 0.00020838 | 0.00020838 |   0.0 |  0.00
Modify  | 0.37909    | 0.37909    | 0.37909    |   0.0 |  0.36
Other   |            | 0.06035    |            |       |  0.06

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

Total # of neighbors = 127932
Ave neighs/atom = 63.966
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.548982371796, Press = 0.599058850506563
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -8025.8385     -8025.8385     -8109.74       -8109.74        324.70733      324.70733      24121.11       24121.11      -973.03608     -973.03608    
     64000  -8023.4427     -8023.4427     -8109.5482     -8109.5482      333.23739      333.23739      24126.996      24126.996     -1381.5245     -1381.5245    
Loop time of 104.833 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.120 hours/ns, 9.539 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.3      | 104.3      | 104.3      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098059   | 0.098059   | 0.098059   |   0.0 |  0.09
Output  | 0.00020664 | 0.00020664 | 0.00020664 |   0.0 |  0.00
Modify  | 0.37271    | 0.37271    | 0.37271    |   0.0 |  0.36
Other   |            | 0.0602     |            |       |  0.06

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

Total # of neighbors = 127948
Ave neighs/atom = 63.974
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.558271311291, Press = 0.369831696421178
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -8023.4427     -8023.4427     -8109.5482     -8109.5482      333.23739      333.23739      24126.996      24126.996     -1381.5245     -1381.5245    
     65000  -8017.0437     -8017.0437     -8105.6232     -8105.6232      342.81153      342.81153      24138.668      24138.668     -1622.7234     -1622.7234    
Loop time of 105.481 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.300 hours/ns, 9.480 timesteps/s
99.9% 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.95     | 104.95     | 104.95     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098859   | 0.098859   | 0.098859   |   0.0 |  0.09
Output  | 0.00016845 | 0.00016845 | 0.00016845 |   0.0 |  0.00
Modify  | 0.37656    | 0.37656    | 0.37656    |   0.0 |  0.36
Other   |            | 0.05994    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.596356609818, Press = -0.149081361785325
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -8017.0437     -8017.0437     -8105.6232     -8105.6232      342.81153      342.81153      24138.668      24138.668     -1622.7234     -1622.7234    
     66000  -8023.569      -8023.569      -8107.9894     -8107.9894      326.7157       326.7157       24131.126      24131.126     -1419.2652     -1419.2652    
Loop time of 107.365 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.805 ns/day, 29.824 hours/ns, 9.314 timesteps/s
99.9% 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.82     | 106.82     | 106.82     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10024    | 0.10024    | 0.10024    |   0.0 |  0.09
Output  | 0.00016444 | 0.00016444 | 0.00016444 |   0.0 |  0.00
Modify  | 0.38442    | 0.38442    | 0.38442    |   0.0 |  0.36
Other   |            | 0.06016    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.627937375098, Press = -0.846903097974951
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -8023.569      -8023.569      -8107.9894     -8107.9894      326.7157       326.7157       24131.126      24131.126     -1419.2652     -1419.2652    
     67000  -8020.2919     -8020.2919     -8106.8432     -8106.8432      334.96245      334.96245      24122.277      24122.277     -465.37419     -465.37419    
Loop time of 105.06 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.183 hours/ns, 9.518 timesteps/s
99.9% 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.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098581   | 0.098581   | 0.098581   |   0.0 |  0.09
Output  | 0.00016501 | 0.00016501 | 0.00016501 |   0.0 |  0.00
Modify  | 0.37578    | 0.37578    | 0.37578    |   0.0 |  0.36
Other   |            | 0.06007    |            |       |  0.06

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

Total # of neighbors = 127920
Ave neighs/atom = 63.96
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.66715776574, Press = -1.09198978105229
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -8020.2919     -8020.2919     -8106.8432     -8106.8432      334.96245      334.96245      24122.277      24122.277     -465.37419     -465.37419    
     68000  -8021.825      -8021.825      -8106.5902     -8106.5902      328.04998      328.04998      24106.229      24106.229      745.30634      745.30634    
Loop time of 106.321 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.534 hours/ns, 9.405 timesteps/s
99.9% 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.78     | 105.78     | 105.78     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099145   | 0.099145   | 0.099145   |   0.0 |  0.09
Output  | 0.00017212 | 0.00017212 | 0.00017212 |   0.0 |  0.00
Modify  | 0.38128    | 0.38128    | 0.38128    |   0.0 |  0.36
Other   |            | 0.06053    |            |       |  0.06

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

Total # of neighbors = 127918
Ave neighs/atom = 63.959
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.71225254741, Press = -0.81575050151025
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -8021.825      -8021.825      -8106.5902     -8106.5902      328.04998      328.04998      24106.229      24106.229      745.30634      745.30634    
     69000  -8019.6163     -8019.6163     -8105.5929     -8105.5929      332.73823      332.73823      24104.624      24104.624      1027.3986      1027.3986    
Loop time of 106.098 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.472 hours/ns, 9.425 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.56     | 105.56     | 105.56     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098811   | 0.098811   | 0.098811   |   0.0 |  0.09
Output  | 0.00019973 | 0.00019973 | 0.00019973 |   0.0 |  0.00
Modify  | 0.37894    | 0.37894    | 0.37894    |   0.0 |  0.36
Other   |            | 0.06024    |            |       |  0.06

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

Total # of neighbors = 127942
Ave neighs/atom = 63.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.73324050894, Press = 0.0112092510852491
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -8019.6163     -8019.6163     -8105.5929     -8105.5929      332.73823      332.73823      24104.624      24104.624      1027.3986      1027.3986    
     70000  -8019.9724     -8019.9724     -8106.9593     -8106.9593      336.64838      336.64838      24105.991      24105.991      780.01009      780.01009    
Loop time of 106.103 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.473 hours/ns, 9.425 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.56     | 105.56     | 105.56     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098808   | 0.098808   | 0.098808   |   0.0 |  0.09
Output  | 0.00016525 | 0.00016525 | 0.00016525 |   0.0 |  0.00
Modify  | 0.37921    | 0.37921    | 0.37921    |   0.0 |  0.36
Other   |            | 0.06014    |            |       |  0.06

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

Total # of neighbors = 127910
Ave neighs/atom = 63.955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.794992120931, Press = -0.00562864291195754
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -8019.9724     -8019.9724     -8106.9593     -8106.9593      336.64838      336.64838      24105.991      24105.991      780.01009      780.01009    
     71000  -8020.7091     -8020.7091     -8106.902      -8106.902       333.57547      333.57547      24094.879      24094.879      1522.1768      1522.1768    
Loop time of 104.609 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.058 hours/ns, 9.559 timesteps/s
99.9% 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.08     | 104.08     | 104.08     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098567   | 0.098567   | 0.098567   |   0.0 |  0.09
Output  | 0.00016653 | 0.00016653 | 0.00016653 |   0.0 |  0.00
Modify  | 0.37343    | 0.37343    | 0.37343    |   0.0 |  0.36
Other   |            | 0.06006    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127924 ave      127924 max      127924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127924
Ave neighs/atom = 63.962
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.808359451191, Press = 0.014344911573111
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -8020.7091     -8020.7091     -8106.902      -8106.902       333.57547      333.57547      24094.879      24094.879      1522.1768      1522.1768    
     72000  -8021.9799     -8021.9799     -8107.4658     -8107.4658      330.83915      330.83915      24072.543      24072.543      3146.6976      3146.6976    
Loop time of 107.378 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.805 ns/day, 29.827 hours/ns, 9.313 timesteps/s
99.9% 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.83     | 106.83     | 106.83     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10001    | 0.10001    | 0.10001    |   0.0 |  0.09
Output  | 0.00016543 | 0.00016543 | 0.00016543 |   0.0 |  0.00
Modify  | 0.38448    | 0.38448    | 0.38448    |   0.0 |  0.36
Other   |            | 0.06106    |            |       |  0.06

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

Total # of neighbors = 127930
Ave neighs/atom = 63.965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.863385226599, Press = 0.267858752493798
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -8021.9799     -8021.9799     -8107.4658     -8107.4658      330.83915      330.83915      24072.543      24072.543      3146.6976      3146.6976    
     73000  -8020.8573     -8020.8573     -8109.211      -8109.211       341.93816      341.93816      24056.789      24056.789      4169.4421      4169.4421    
Loop time of 106.253 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.515 hours/ns, 9.412 timesteps/s
99.9% 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.71     | 105.71     | 105.71     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099597   | 0.099597   | 0.099597   |   0.0 |  0.09
Output  | 0.00016585 | 0.00016585 | 0.00016585 |   0.0 |  0.00
Modify  | 0.37956    | 0.37956    | 0.37956    |   0.0 |  0.36
Other   |            | 0.06072    |            |       |  0.06

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

Total # of neighbors = 127958
Ave neighs/atom = 63.979
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.878726541023, Press = 0.914902815014644
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -8020.8573     -8020.8573     -8109.211      -8109.211       341.93816      341.93816      24056.789      24056.789      4169.4421      4169.4421    
     74000  -8019.5815     -8019.5815     -8105.6048     -8105.6048      332.91907      332.91907      24093.207      24093.207      1633.1792      1633.1792    
Loop time of 106.322 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.534 hours/ns, 9.405 timesteps/s
99.9% 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.78     | 105.78     | 105.78     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098525   | 0.098525   | 0.098525   |   0.0 |  0.09
Output  | 0.00016275 | 0.00016275 | 0.00016275 |   0.0 |  0.00
Modify  | 0.37867    | 0.37867    | 0.37867    |   0.0 |  0.36
Other   |            | 0.06021    |            |       |  0.06

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

Total # of neighbors = 127956
Ave neighs/atom = 63.978
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.905650366439, Press = 0.988923589817301
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -8019.5815     -8019.5815     -8105.6048     -8105.6048      332.91907      332.91907      24093.207      24093.207      1633.1792      1633.1792    
     75000  -8025.0835     -8025.0835     -8110.4102     -8110.4102      330.22313      330.22313      24102.828      24102.828      419.52016      419.52016    
Loop time of 105.085 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.190 hours/ns, 9.516 timesteps/s
99.9% 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.55     | 104.55     | 104.55     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098396   | 0.098396   | 0.098396   |   0.0 |  0.09
Output  | 0.00016534 | 0.00016534 | 0.00016534 |   0.0 |  0.00
Modify  | 0.37482    | 0.37482    | 0.37482    |   0.0 |  0.36
Other   |            | 0.06042    |            |       |  0.06

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

Total # of neighbors = 127944
Ave neighs/atom = 63.972
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.879054055717, Press = 0.838171953964932
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -8025.0835     -8025.0835     -8110.4102     -8110.4102      330.22313      330.22313      24102.828      24102.828      419.52016      419.52016    
     76000  -8020.411      -8020.411      -8106.4014     -8106.4014      332.79194      332.79194      24113.628      24113.628      12.134059      12.134059    
Loop time of 106.38 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.84     | 105.84     | 105.84     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09925    | 0.09925    | 0.09925    |   0.0 |  0.09
Output  | 0.00016372 | 0.00016372 | 0.00016372 |   0.0 |  0.00
Modify  | 0.38068    | 0.38068    | 0.38068    |   0.0 |  0.36
Other   |            | 0.06076    |            |       |  0.06

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

Total # of neighbors = 127926
Ave neighs/atom = 63.963
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.849255863357, Press = 0.833066487061893
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -8020.411      -8020.411      -8106.4014     -8106.4014      332.79194      332.79194      24113.628      24113.628      12.134059      12.134059    
     77000  -8026.0939     -8026.0939     -8111.591      -8111.591       330.8827       330.8827       24108.77       24108.77      -152.28394     -152.28394    
Loop time of 105.297 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.76     | 104.76     | 104.76     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097867   | 0.097867   | 0.097867   |   0.0 |  0.09
Output  | 0.00016591 | 0.00016591 | 0.00016591 |   0.0 |  0.00
Modify  | 0.37349    | 0.37349    | 0.37349    |   0.0 |  0.35
Other   |            | 0.06059    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.831257490282, Press = 0.964789848891472
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -8026.0939     -8026.0939     -8111.591      -8111.591       330.8827       330.8827       24108.77       24108.77      -152.28394     -152.28394    
     78000  -8020.0146     -8020.0146     -8106.9205     -8106.9205      336.33469      336.33469      24146.417      24146.417     -2569.8076     -2569.8076    
Loop time of 105.026 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.49     | 104.49     | 104.49     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098102   | 0.098102   | 0.098102   |   0.0 |  0.09
Output  | 0.0001637  | 0.0001637  | 0.0001637  |   0.0 |  0.00
Modify  | 0.37466    | 0.37466    | 0.37466    |   0.0 |  0.36
Other   |            | 0.06066    |            |       |  0.06

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

Total # of neighbors = 127934
Ave neighs/atom = 63.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.82510481232, Press = 1.74856680728683
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -8020.0146     -8020.0146     -8106.9205     -8106.9205      336.33469      336.33469      24146.417      24146.417     -2569.8076     -2569.8076    
     79000  -8023.4311     -8023.4311     -8108.385      -8108.385       328.78064      328.78064      24147.724      24147.724     -2863.3985     -2863.3985    
Loop time of 106.824 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.673 hours/ns, 9.361 timesteps/s
99.9% 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.28     | 106.28     | 106.28     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098531   | 0.098531   | 0.098531   |   0.0 |  0.09
Output  | 0.00016334 | 0.00016334 | 0.00016334 |   0.0 |  0.00
Modify  | 0.38231    | 0.38231    | 0.38231    |   0.0 |  0.36
Other   |            | 0.06093    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.815722608401, Press = 1.16727148346077
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -8023.4311     -8023.4311     -8108.385      -8108.385       328.78064      328.78064      24147.724      24147.724     -2863.3985     -2863.3985    
     80000  -8021.3456     -8021.3456     -8108.3954     -8108.3954      336.89172      336.89172      24150.139      24150.139     -2988.1825     -2988.1825    
Loop time of 106.264 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.518 hours/ns, 9.411 timesteps/s
99.9% 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.72     | 105.72     | 105.72     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099615   | 0.099615   | 0.099615   |   0.0 |  0.09
Output  | 0.00016781 | 0.00016781 | 0.00016781 |   0.0 |  0.00
Modify  | 0.37919    | 0.37919    | 0.37919    |   0.0 |  0.36
Other   |            | 0.06093    |            |       |  0.06

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

Total # of neighbors = 127926
Ave neighs/atom = 63.963
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.808706407296, Press = 0.694919271308243
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -8021.3456     -8021.3456     -8108.3954     -8108.3954      336.89172      336.89172      24150.139      24150.139     -2988.1825     -2988.1825    
     81000  -8026.6666     -8026.6666     -8110.7069     -8110.7069      325.24468      325.24468      24136.708      24136.708     -2302.6541     -2302.6541    
Loop time of 105.913 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.420 hours/ns, 9.442 timesteps/s
99.9% 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.37     | 105.37     | 105.37     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098253   | 0.098253   | 0.098253   |   0.0 |  0.09
Output  | 0.00016325 | 0.00016325 | 0.00016325 |   0.0 |  0.00
Modify  | 0.37857    | 0.37857    | 0.37857    |   0.0 |  0.36
Other   |            | 0.0609     |            |       |  0.06

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

Total # of neighbors = 127898
Ave neighs/atom = 63.949
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.783255967201, Press = 0.29241451415204
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -8026.6666     -8026.6666     -8110.7069     -8110.7069      325.24468      325.24468      24136.708      24136.708     -2302.6541     -2302.6541    
     82000  -8019.2746     -8019.2746     -8106.5506     -8106.5506      337.76723      337.76723      24138.425      24138.425     -1869.4719     -1869.4719    
Loop time of 105.903 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.418 hours/ns, 9.443 timesteps/s
99.9% 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.37     | 105.37     | 105.37     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098228   | 0.098228   | 0.098228   |   0.0 |  0.09
Output  | 0.00025606 | 0.00025606 | 0.00025606 |   0.0 |  0.00
Modify  | 0.37799    | 0.37799    | 0.37799    |   0.0 |  0.36
Other   |            | 0.0606     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127936 ave      127936 max      127936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127936
Ave neighs/atom = 63.968
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.776519315177, Press = -0.017686411086941
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -8019.2746     -8019.2746     -8106.5506     -8106.5506      337.76723      337.76723      24138.425      24138.425     -1869.4719     -1869.4719    
     83000  -8022.4761     -8022.4761     -8106.87       -8106.87        326.613        326.613        24119.948      24119.948     -478.75887     -478.75887    
Loop time of 106.288 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.525 hours/ns, 9.408 timesteps/s
99.9% 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.75     | 105.75     | 105.75     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098952   | 0.098952   | 0.098952   |   0.0 |  0.09
Output  | 0.00021164 | 0.00021164 | 0.00021164 |   0.0 |  0.00
Modify  | 0.38004    | 0.38004    | 0.38004    |   0.0 |  0.36
Other   |            | 0.06075    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127894 ave      127894 max      127894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127894
Ave neighs/atom = 63.947
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.77017503992, Press = -0.01125530007328
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -8022.4761     -8022.4761     -8106.87       -8106.87        326.613        326.613        24119.948      24119.948     -478.75887     -478.75887    
     84000  -8024.9496     -8024.9496     -8107.2467     -8107.2467      318.49849      318.49849      24110.787      24110.787      132.11391      132.11391    
Loop time of 105.47 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.93     | 104.93     | 104.93     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098126   | 0.098126   | 0.098126   |   0.0 |  0.09
Output  | 0.00020904 | 0.00020904 | 0.00020904 |   0.0 |  0.00
Modify  | 0.37688    | 0.37688    | 0.37688    |   0.0 |  0.36
Other   |            | 0.06061    |            |       |  0.06

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

Total # of neighbors = 127958
Ave neighs/atom = 63.979
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.748024892446, Press = 0.104630647373433
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -8024.9496     -8024.9496     -8107.2467     -8107.2467      318.49849      318.49849      24110.787      24110.787      132.11391      132.11391    
     85000  -8022.6021     -8022.6021     -8108.3299     -8108.3299      331.7756       331.7756       24110.743      24110.743      165.28563      165.28563    
Loop time of 107.561 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.803 ns/day, 29.878 hours/ns, 9.297 timesteps/s
99.9% 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.02     | 107.02     | 107.02     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099984   | 0.099984   | 0.099984   |   0.0 |  0.09
Output  | 0.00016409 | 0.00016409 | 0.00016409 |   0.0 |  0.00
Modify  | 0.38526    | 0.38526    | 0.38526    |   0.0 |  0.36
Other   |            | 0.06046    |            |       |  0.06

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

Total # of neighbors = 127938
Ave neighs/atom = 63.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.773861439094, Press = 0.000753308994210678
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -8022.6021     -8022.6021     -8108.3299     -8108.3299      331.7756       331.7756       24110.743      24110.743      165.28563      165.28563    
     86000  -8023.6693     -8023.6693     -8108.7144     -8108.7144      329.13299      329.13299      24116.22       24116.22      -238.78937     -238.78937    
Loop time of 106.883 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.690 hours/ns, 9.356 timesteps/s
99.9% 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.34     | 106.34     | 106.34     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099681   | 0.099681   | 0.099681   |   0.0 |  0.09
Output  | 0.00021117 | 0.00021117 | 0.00021117 |   0.0 |  0.00
Modify  | 0.38301    | 0.38301    | 0.38301    |   0.0 |  0.36
Other   |            | 0.06061    |            |       |  0.06

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

Total # of neighbors = 127934
Ave neighs/atom = 63.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.78622903512, Press = -0.212979818127997
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -8023.6693     -8023.6693     -8108.7144     -8108.7144      329.13299      329.13299      24116.22       24116.22      -238.78937     -238.78937    
     87000  -8025.2328     -8025.2328     -8110.4751     -8110.4751      329.89642      329.89642      24107.46       24107.46       85.405565      85.405565    
Loop time of 106.391 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.85     | 105.85     | 105.85     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09916    | 0.09916    | 0.09916    |   0.0 |  0.09
Output  | 0.00021441 | 0.00021441 | 0.00021441 |   0.0 |  0.00
Modify  | 0.3791     | 0.3791     | 0.3791     |   0.0 |  0.36
Other   |            | 0.06026    |            |       |  0.06

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

Total # of neighbors = 127952
Ave neighs/atom = 63.976
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.789672960746, Press = -0.903696297878444
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -8025.2328     -8025.2328     -8110.4751     -8110.4751      329.89642      329.89642      24107.46       24107.46       85.405565      85.405565    
     88000  -8021.1704     -8021.1704     -8108.2554     -8108.2554      337.02781      337.02781      24098.487      24098.487      1161.72        1161.72      
Loop time of 105.873 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.409 hours/ns, 9.445 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.34     | 105.34     | 105.34     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097472   | 0.097472   | 0.097472   |   0.0 |  0.09
Output  | 0.0001683  | 0.0001683  | 0.0001683  |   0.0 |  0.00
Modify  | 0.37513    | 0.37513    | 0.37513    |   0.0 |  0.35
Other   |            | 0.06067    |            |       |  0.06

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

Total # of neighbors = 127924
Ave neighs/atom = 63.962
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.75839616501, Press = -0.628788263957164
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -8021.1704     -8021.1704     -8108.2554     -8108.2554      337.02781      337.02781      24098.487      24098.487      1161.72        1161.72      
     89000  -8026.1738     -8026.1738     -8108.6967     -8108.6967      319.37208      319.37208      24084.698      24084.698      2049.5546      2049.5546    
Loop time of 107.519 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.866 hours/ns, 9.301 timesteps/s
99.9% 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.97     | 106.97     | 106.97     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099665   | 0.099665   | 0.099665   |   0.0 |  0.09
Output  | 0.00016477 | 0.00016477 | 0.00016477 |   0.0 |  0.00
Modify  | 0.38436    | 0.38436    | 0.38436    |   0.0 |  0.36
Other   |            | 0.06076    |            |       |  0.06

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

Total # of neighbors = 127936
Ave neighs/atom = 63.968
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.743168648365, Press = -0.2161854488882
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -8026.1738     -8026.1738     -8108.6967     -8108.6967      319.37208      319.37208      24084.698      24084.698      2049.5546      2049.5546    
     90000  -8021.9626     -8021.9626     -8110.2305     -8110.2305      341.60566      341.60566      24096.373      24096.373      1108.8989      1108.8989    
Loop time of 106.965 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.712 hours/ns, 9.349 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.42     | 106.42     | 106.42     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099639   | 0.099639   | 0.099639   |   0.0 |  0.09
Output  | 0.00038164 | 0.00038164 | 0.00038164 |   0.0 |  0.00
Modify  | 0.38254    | 0.38254    | 0.38254    |   0.0 |  0.36
Other   |            | 0.06125    |            |       |  0.06

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

Total # of neighbors = 127948
Ave neighs/atom = 63.974
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.743293631717, Press = 0.0543107850724066
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     90000  -8021.9626     -8021.9626     -8110.2305     -8110.2305      341.60566      341.60566      24096.373      24096.373      1108.8989      1108.8989    
     91000  -8016.4309     -8016.4309     -8106.3392     -8106.3392      347.9545       347.9545       24110.057      24110.057      658.69406      658.69406    
Loop time of 106.776 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.660 hours/ns, 9.365 timesteps/s
99.9% 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.24     | 106.24     | 106.24     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098712   | 0.098712   | 0.098712   |   0.0 |  0.09
Output  | 0.00016239 | 0.00016239 | 0.00016239 |   0.0 |  0.00
Modify  | 0.37854    | 0.37854    | 0.37854    |   0.0 |  0.35
Other   |            | 0.06105    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.758127127977, Press = 0.248154405622069
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     91000  -8016.4309     -8016.4309     -8106.3392     -8106.3392      347.9545       347.9545       24110.057      24110.057      658.69406      658.69406    
     92000  -8022.6205     -8022.6205     -8109.0034     -8109.0034      334.31063      334.31063      24107.498      24107.498      307.753        307.753      
Loop time of 106.686 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.635 hours/ns, 9.373 timesteps/s
99.9% 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.14     | 106.14     | 106.14     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099117   | 0.099117   | 0.099117   |   0.0 |  0.09
Output  | 0.00016484 | 0.00016484 | 0.00016484 |   0.0 |  0.00
Modify  | 0.38189    | 0.38189    | 0.38189    |   0.0 |  0.36
Other   |            | 0.06077    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127932 ave      127932 max      127932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127932
Ave neighs/atom = 63.966
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.783896607234, Press = 0.198548033116253
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     92000  -8022.6205     -8022.6205     -8109.0034     -8109.0034      334.31063      334.31063      24107.498      24107.498      307.753        307.753      
     93000  -8019.0307     -8019.0307     -8107.5168     -8107.5168      342.45063      342.45063      24104.428      24104.428      852.719        852.719      
Loop time of 105.688 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.358 hours/ns, 9.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    | 105.15     | 105.15     | 105.15     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097877   | 0.097877   | 0.097877   |   0.0 |  0.09
Output  | 0.00016524 | 0.00016524 | 0.00016524 |   0.0 |  0.00
Modify  | 0.37569    | 0.37569    | 0.37569    |   0.0 |  0.36
Other   |            | 0.0607     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127938 ave      127938 max      127938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127938
Ave neighs/atom = 63.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.816217340784, Press = 0.122187417073005
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -8019.0307     -8019.0307     -8107.5168     -8107.5168      342.45063      342.45063      24104.428      24104.428      852.719        852.719      
     94000  -8025.002      -8025.002      -8109.8446     -8109.8446      328.34953      328.34953      24085.935      24085.935      1802.5102      1802.5102    
Loop time of 105.905 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.418 hours/ns, 9.442 timesteps/s
99.9% 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.37     | 105.37     | 105.37     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098794   | 0.098794   | 0.098794   |   0.0 |  0.09
Output  | 0.00016659 | 0.00016659 | 0.00016659 |   0.0 |  0.00
Modify  | 0.37875    | 0.37875    | 0.37875    |   0.0 |  0.36
Other   |            | 0.06095    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127928 ave      127928 max      127928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127928
Ave neighs/atom = 63.964
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.814877208395, Press = 0.242409763322837
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -8025.002      -8025.002      -8109.8446     -8109.8446      328.34953      328.34953      24085.935      24085.935      1802.5102      1802.5102    
     95000  -8021.667      -8021.667      -8109.1117     -8109.1117      338.42027      338.42027      24074.79       24074.79       2859.7018      2859.7018    
Loop time of 106.537 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.594 hours/ns, 9.386 timesteps/s
99.9% 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        | 106        | 106        |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098546   | 0.098546   | 0.098546   |   0.0 |  0.09
Output  | 0.00019996 | 0.00019996 | 0.00019996 |   0.0 |  0.00
Modify  | 0.38086    | 0.38086    | 0.38086    |   0.0 |  0.36
Other   |            | 0.0608     |            |       |  0.06

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

Total # of neighbors = 127942
Ave neighs/atom = 63.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.810555633578, Press = 0.661087163835713
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -8021.667      -8021.667      -8109.1117     -8109.1117      338.42027      338.42027      24074.79       24074.79       2859.7018      2859.7018    
     96000  -8022.8298     -8022.8298     -8109.9676     -8109.9676      337.23221      337.23221      24076.309      24076.309      2499.8972      2499.8972    
Loop time of 105.894 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.415 hours/ns, 9.443 timesteps/s
99.9% 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.35     | 105.35     | 105.35     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098941   | 0.098941   | 0.098941   |   0.0 |  0.09
Output  | 0.00016496 | 0.00016496 | 0.00016496 |   0.0 |  0.00
Modify  | 0.38095    | 0.38095    | 0.38095    |   0.0 |  0.36
Other   |            | 0.06092    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127942 ave      127942 max      127942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127942
Ave neighs/atom = 63.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.818727346174, Press = 0.902077492660501
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -8022.8298     -8022.8298     -8109.9676     -8109.9676      337.23221      337.23221      24076.309      24076.309      2499.8972      2499.8972    
     97000  -8020.4622     -8020.4622     -8107.2212     -8107.2212      335.76639      335.76639      24089.382      24089.382      1909.697       1909.697     
Loop time of 106.806 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.668 hours/ns, 9.363 timesteps/s
99.9% 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.26     | 106.26     | 106.26     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099593   | 0.099593   | 0.099593   |   0.0 |  0.09
Output  | 0.00016617 | 0.00016617 | 0.00016617 |   0.0 |  0.00
Modify  | 0.38187    | 0.38187    | 0.38187    |   0.0 |  0.36
Other   |            | 0.06089    |            |       |  0.06

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

Total # of neighbors = 127938
Ave neighs/atom = 63.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.79912304369, Press = 0.815240081486208
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     97000  -8020.4622     -8020.4622     -8107.2212     -8107.2212      335.76639      335.76639      24089.382      24089.382      1909.697       1909.697     
     98000  -8021.745      -8021.745      -8108.5832     -8108.5832      336.07306      336.07306      24104.949      24104.949      538.87197      538.87197    
Loop time of 105.89 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.414 hours/ns, 9.444 timesteps/s
99.9% 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.35     | 105.35     | 105.35     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098769   | 0.098769   | 0.098769   |   0.0 |  0.09
Output  | 0.00016386 | 0.00016386 | 0.00016386 |   0.0 |  0.00
Modify  | 0.37742    | 0.37742    | 0.37742    |   0.0 |  0.36
Other   |            | 0.06086    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127958 ave      127958 max      127958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127958
Ave neighs/atom = 63.979
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.795455652037, Press = 0.656150714755693
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -8021.745      -8021.745      -8108.5832     -8108.5832      336.07306      336.07306      24104.949      24104.949      538.87197      538.87197    
     99000  -8022.5316     -8022.5316     -8108.1287     -8108.1287      331.26943      331.26943      24108.838      24108.838      262.9036       262.9036     
Loop time of 107.378 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.805 ns/day, 29.827 hours/ns, 9.313 timesteps/s
99.9% 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.83     | 106.83     | 106.83     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09917    | 0.09917    | 0.09917    |   0.0 |  0.09
Output  | 0.00016764 | 0.00016764 | 0.00016764 |   0.0 |  0.00
Modify  | 0.38502    | 0.38502    | 0.38502    |   0.0 |  0.36
Other   |            | 0.06146    |            |       |  0.06

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

Total # of neighbors = 127930
Ave neighs/atom = 63.965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.787736100749, Press = 0.508934687155432
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -8022.5316     -8022.5316     -8108.1287     -8108.1287      331.26943      331.26943      24108.838      24108.838      262.9036       262.9036     
    100000  -8022.1017     -8022.1017     -8108.2751     -8108.2751      333.49985      333.49985      24108.387      24108.387      337.36817      337.36817    
Loop time of 106.355 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.81     | 105.81     | 105.81     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099167   | 0.099167   | 0.099167   |   0.0 |  0.09
Output  | 0.00016672 | 0.00016672 | 0.00016672 |   0.0 |  0.00
Modify  | 0.38144    | 0.38144    | 0.38144    |   0.0 |  0.36
Other   |            | 0.06061    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.799583385796, Press = 0.46802357224566
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    100000  -8022.1017     -8022.1017     -8108.2751     -8108.2751      333.49985      333.49985      24108.387      24108.387      337.36817      337.36817    
    101000  -8018.7275     -8018.7275     -8106.3353     -8106.3353      339.05117      339.05117      24117.507      24117.507     -6.1568543     -6.1568543    
Loop time of 108.092 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.799 ns/day, 30.026 hours/ns, 9.251 timesteps/s
99.9% 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.54     | 107.54     | 107.54     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1002     | 0.1002     | 0.1002     |   0.0 |  0.09
Output  | 0.00016203 | 0.00016203 | 0.00016203 |   0.0 |  0.00
Modify  | 0.38908    | 0.38908    | 0.38908    |   0.0 |  0.36
Other   |            | 0.06116    |            |       |  0.06

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

Total # of neighbors = 127916
Ave neighs/atom = 63.958
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.804688873205, Press = 0.563261783654871
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -8018.7275     -8018.7275     -8106.3353     -8106.3353      339.05117      339.05117      24117.507      24117.507     -6.1568543     -6.1568543    
    102000  -8021.0492     -8021.0492     -8109.6773     -8109.6773      342.99985      342.99985      24117.116      24117.116     -496.89643     -496.89643    
Loop time of 107.09 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.807 ns/day, 29.747 hours/ns, 9.338 timesteps/s
99.9% 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.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099131   | 0.099131   | 0.099131   |   0.0 |  0.09
Output  | 0.00016307 | 0.00016307 | 0.00016307 |   0.0 |  0.00
Modify  | 0.38639    | 0.38639    | 0.38639    |   0.0 |  0.36
Other   |            | 0.06044    |            |       |  0.06

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

Total # of neighbors = 127934
Ave neighs/atom = 63.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.844845044584, Press = 0.447671379314075
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    102000  -8021.0492     -8021.0492     -8109.6773     -8109.6773      342.99985      342.99985      24117.116      24117.116     -496.89643     -496.89643    
    103000  -8021.8973     -8021.8973     -8108.4935     -8108.4935      335.13638      335.13638      24126.571      24126.571     -1141.9382     -1141.9382    
Loop time of 106.685 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.635 hours/ns, 9.373 timesteps/s
99.9% 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.14     | 106.14     | 106.14     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098928   | 0.098928   | 0.098928   |   0.0 |  0.09
Output  | 0.00016725 | 0.00016725 | 0.00016725 |   0.0 |  0.00
Modify  | 0.38239    | 0.38239    | 0.38239    |   0.0 |  0.36
Other   |            | 0.06046    |            |       |  0.06

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

Total # of neighbors = 127934
Ave neighs/atom = 63.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.861771974985, Press = 0.678790124283684
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    103000  -8021.8973     -8021.8973     -8108.4935     -8108.4935      335.13638      335.13638      24126.571      24126.571     -1141.9382     -1141.9382    
    104000  -8024.5006     -8024.5006     -8109.2047     -8109.2047      327.81341      327.81341      24143.304      24143.304     -2471.161      -2471.161     
Loop time of 105.789 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.386 hours/ns, 9.453 timesteps/s
99.9% 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.25     | 105.25     | 105.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098465   | 0.098465   | 0.098465   |   0.0 |  0.09
Output  | 0.00016564 | 0.00016564 | 0.00016564 |   0.0 |  0.00
Modify  | 0.37776    | 0.37776    | 0.37776    |   0.0 |  0.36
Other   |            | 0.06095    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127936 ave      127936 max      127936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127936
Ave neighs/atom = 63.968
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.885604784827, Press = 0.905905273070456
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    104000  -8024.5006     -8024.5006     -8109.2047     -8109.2047      327.81341      327.81341      24143.304      24143.304     -2471.161      -2471.161     
    105000  -8020.786      -8020.786      -8107.7136     -8107.7136      336.41863      336.41863      24152.601      24152.601     -3085.714      -3085.714     
Loop time of 108.217 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.798 ns/day, 30.060 hours/ns, 9.241 timesteps/s
99.9% 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.67     | 107.67     | 107.67     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10022    | 0.10022    | 0.10022    |   0.0 |  0.09
Output  | 0.00016604 | 0.00016604 | 0.00016604 |   0.0 |  0.00
Modify  | 0.38954    | 0.38954    | 0.38954    |   0.0 |  0.36
Other   |            | 0.06161    |            |       |  0.06

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

Total # of neighbors = 127920
Ave neighs/atom = 63.96
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.883708548045, Press = 0.534941677386661
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    105000  -8020.786      -8020.786      -8107.7136     -8107.7136      336.41863      336.41863      24152.601      24152.601     -3085.714      -3085.714     
    106000  -8024.6446     -8024.6446     -8108.3015     -8108.3015      323.76076      323.76076      24124.018      24124.018     -1083.6886     -1083.6886    
Loop time of 107.339 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.805 ns/day, 29.816 hours/ns, 9.316 timesteps/s
99.9% 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.8      | 106.8      | 106.8      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099535   | 0.099535   | 0.099535   |   0.0 |  0.09
Output  | 0.00017979 | 0.00017979 | 0.00017979 |   0.0 |  0.00
Modify  | 0.38309    | 0.38309    | 0.38309    |   0.0 |  0.36
Other   |            | 0.06073    |            |       |  0.06

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

Total # of neighbors = 127912
Ave neighs/atom = 63.956
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.85607909814, Press = 0.181398264153502
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    106000  -8024.6446     -8024.6446     -8108.3015     -8108.3015      323.76076      323.76076      24124.018      24124.018     -1083.6886     -1083.6886    
    107000  -8019.8807     -8019.8807     -8106.6353     -8106.6353      335.74912      335.74912      24119.617      24119.617     -309.72717     -309.72717    
Loop time of 107.488 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.858 hours/ns, 9.303 timesteps/s
99.9% 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.94     | 106.94     | 106.94     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098723   | 0.098723   | 0.098723   |   0.0 |  0.09
Output  | 0.0001661  | 0.0001661  | 0.0001661  |   0.0 |  0.00
Modify  | 0.38381    | 0.38381    | 0.38381    |   0.0 |  0.36
Other   |            | 0.06081    |            |       |  0.06

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

Total # of neighbors = 127946
Ave neighs/atom = 63.973
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.839786991818, Press = 0.034591702244356
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    107000  -8019.8807     -8019.8807     -8106.6353     -8106.6353      335.74912      335.74912      24119.617      24119.617     -309.72717     -309.72717    
    108000  -8022.6023     -8022.6023     -8109.3947     -8109.3947      335.89554      335.89554      24111.039      24111.039     -63.915549     -63.915549    
Loop time of 106.601 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.06     | 106.06     | 106.06     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10025    | 0.10025    | 0.10025    |   0.0 |  0.09
Output  | 0.00019982 | 0.00019982 | 0.00019982 |   0.0 |  0.00
Modify  | 0.3809     | 0.3809     | 0.3809     |   0.0 |  0.36
Other   |            | 0.06037    |            |       |  0.06

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

Total # of neighbors = 127920
Ave neighs/atom = 63.96
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.833125530086, Press = 0.011691732748223
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    108000  -8022.6023     -8022.6023     -8109.3947     -8109.3947      335.89554      335.89554      24111.039      24111.039     -63.915549     -63.915549    
    109000  -8019.7356     -8019.7356     -8107.7627     -8107.7627      340.67381      340.67381      24115.351      24115.351     -120.98124     -120.98124    
Loop time of 107.066 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.807 ns/day, 29.741 hours/ns, 9.340 timesteps/s
99.9% 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.52     | 106.52     | 106.52     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099928   | 0.099928   | 0.099928   |   0.0 |  0.09
Output  | 0.00016437 | 0.00016437 | 0.00016437 |   0.0 |  0.00
Modify  | 0.38452    | 0.38452    | 0.38452    |   0.0 |  0.36
Other   |            | 0.06139    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127930 ave      127930 max      127930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127930
Ave neighs/atom = 63.965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.8318646789, Press = 0.0534319585661618
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    109000  -8019.7356     -8019.7356     -8107.7627     -8107.7627      340.67381      340.67381      24115.351      24115.351     -120.98124     -120.98124    
    110000  -8024.4354     -8024.4354     -8111.4757     -8111.4757      336.85504      336.85504      24112.712      24112.712     -527.84605     -527.84605    
Loop time of 105.044 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.51     | 104.51     | 104.51     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097666   | 0.097666   | 0.097666   |   0.0 |  0.09
Output  | 0.00020974 | 0.00020974 | 0.00020974 |   0.0 |  0.00
Modify  | 0.37287    | 0.37287    | 0.37287    |   0.0 |  0.35
Other   |            | 0.06017    |            |       |  0.06

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

Total # of neighbors = 127886
Ave neighs/atom = 63.943
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.815133997756, Press = -0.192868327571576
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    110000  -8024.4354     -8024.4354     -8111.4757     -8111.4757      336.85504      336.85504      24112.712      24112.712     -527.84605     -527.84605    
    111000  -8020.9017     -8020.9017     -8109.5825     -8109.5825      343.20389      343.20389      24109.484      24109.484      124.30082      124.30082    
Loop time of 106.935 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.704 hours/ns, 9.351 timesteps/s
99.9% 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.39     | 106.39     | 106.39     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099303   | 0.099303   | 0.099303   |   0.0 |  0.09
Output  | 0.000211   | 0.000211   | 0.000211   |   0.0 |  0.00
Modify  | 0.3838     | 0.3838     | 0.3838     |   0.0 |  0.36
Other   |            | 0.06089    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127954 ave      127954 max      127954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127954
Ave neighs/atom = 63.977
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.811448237454, Press = -0.376654102297309
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    111000  -8020.9017     -8020.9017     -8109.5825     -8109.5825      343.20389      343.20389      24109.484      24109.484      124.30082      124.30082    
    112000  -8024.8873     -8024.8873     -8112.4803     -8112.4803      338.99414      338.99414      24080.395      24080.395      1896.3861      1896.3861    
Loop time of 106.665 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.13     | 106.13     | 106.13     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09837    | 0.09837    | 0.09837    |   0.0 |  0.09
Output  | 0.00016749 | 0.00016749 | 0.00016749 |   0.0 |  0.00
Modify  | 0.37804    | 0.37804    | 0.37804    |   0.0 |  0.35
Other   |            | 0.06038    |            |       |  0.06

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

Total # of neighbors = 127968
Ave neighs/atom = 63.984
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.78871200123, Press = -0.386560197556599
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    112000  -8024.8873     -8024.8873     -8112.4803     -8112.4803      338.99414      338.99414      24080.395      24080.395      1896.3861      1896.3861    
    113000  -8021.6494     -8021.6494     -8108.7435     -8108.7435      337.06331      337.06331      24074.441      24074.441      2879.9792      2879.9792    
Loop time of 108.145 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.799 ns/day, 30.040 hours/ns, 9.247 timesteps/s
99.9% 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.6      | 107.6      | 107.6      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1004     | 0.1004     | 0.1004     |   0.0 |  0.09
Output  | 0.00021827 | 0.00021827 | 0.00021827 |   0.0 |  0.00
Modify  | 0.38634    | 0.38634    | 0.38634    |   0.0 |  0.36
Other   |            | 0.0614     |            |       |  0.06

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

Total # of neighbors = 127960
Ave neighs/atom = 63.98
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.800534330455, Press = -0.195624494820905
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    113000  -8021.6494     -8021.6494     -8108.7435     -8108.7435      337.06331      337.06331      24074.441      24074.441      2879.9792      2879.9792    
    114000  -8024.1361     -8024.1361     -8107.7752     -8107.7752      323.69182      323.69182      24076.718      24076.718      2783.7371      2783.7371    
Loop time of 107.78 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.802 ns/day, 29.939 hours/ns, 9.278 timesteps/s
99.9% 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.23     | 107.23     | 107.23     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10064    | 0.10064    | 0.10064    |   0.0 |  0.09
Output  | 0.00016451 | 0.00016451 | 0.00016451 |   0.0 |  0.00
Modify  | 0.38462    | 0.38462    | 0.38462    |   0.0 |  0.36
Other   |            | 0.06135    |            |       |  0.06

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

Total # of neighbors = 127944
Ave neighs/atom = 63.972
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.79411593425, Press = 0.0139858382096051
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    114000  -8024.1361     -8024.1361     -8107.7752     -8107.7752      323.69182      323.69182      24076.718      24076.718      2783.7371      2783.7371    
    115000  -8025.807      -8025.807      -8109.9934     -8109.9934      325.81029      325.81029      24094.086      24094.086      995.93555      995.93555    
Loop time of 105.993 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.443 hours/ns, 9.435 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.46     | 105.46     | 105.46     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09928    | 0.09928    | 0.09928    |   0.0 |  0.09
Output  | 0.00016741 | 0.00016741 | 0.00016741 |   0.0 |  0.00
Modify  | 0.37796    | 0.37796    | 0.37796    |   0.0 |  0.36
Other   |            | 0.06077    |            |       |  0.06

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

Total # of neighbors = 127948
Ave neighs/atom = 63.974
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.796831452848, Press = 0.180648153561093
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    115000  -8025.807      -8025.807      -8109.9934     -8109.9934      325.81029      325.81029      24094.086      24094.086      995.93555      995.93555    
    116000  -8021.8908     -8021.8908     -8109.0119     -8109.0119      337.16754      337.16754      24104.754      24104.754      493.27291      493.27291    
Loop time of 107.056 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.807 ns/day, 29.738 hours/ns, 9.341 timesteps/s
99.9% 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.51     | 106.51     | 106.51     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099641   | 0.099641   | 0.099641   |   0.0 |  0.09
Output  | 0.00020259 | 0.00020259 | 0.00020259 |   0.0 |  0.00
Modify  | 0.38568    | 0.38568    | 0.38568    |   0.0 |  0.36
Other   |            | 0.06112    |            |       |  0.06

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

Total # of neighbors = 127968
Ave neighs/atom = 63.984
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.7717425887, Press = 0.235323513920476
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    116000  -8021.8908     -8021.8908     -8109.0119     -8109.0119      337.16754      337.16754      24104.754      24104.754      493.27291      493.27291    
    117000  -8021.9722     -8021.9722     -8106.1741     -8106.1741      325.87026      325.87026      24110.426      24110.426      362.93085      362.93085    
Loop time of 105.996 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.443 hours/ns, 9.434 timesteps/s
99.9% 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.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099316   | 0.099316   | 0.099316   |   0.0 |  0.09
Output  | 0.0001645  | 0.0001645  | 0.0001645  |   0.0 |  0.00
Modify  | 0.37793    | 0.37793    | 0.37793    |   0.0 |  0.36
Other   |            | 0.06043    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127962 ave      127962 max      127962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127962
Ave neighs/atom = 63.981
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.785284357832, Press = 0.187371139885679
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    117000  -8021.9722     -8021.9722     -8106.1741     -8106.1741      325.87026      325.87026      24110.426      24110.426      362.93085      362.93085    
    118000  -8020.2549     -8020.2549     -8106.4491     -8106.4491      333.58056      333.58056      24125.219      24125.219     -689.78051     -689.78051    
Loop time of 106.342 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.8      | 105.8      | 105.8      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098702   | 0.098702   | 0.098702   |   0.0 |  0.09
Output  | 0.00016586 | 0.00016586 | 0.00016586 |   0.0 |  0.00
Modify  | 0.3802     | 0.3802     | 0.3802     |   0.0 |  0.36
Other   |            | 0.06161    |            |       |  0.06

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

Total # of neighbors = 127910
Ave neighs/atom = 63.955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.777107966427, Press = 0.36445618744433
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    118000  -8020.2549     -8020.2549     -8106.4491     -8106.4491      333.58056      333.58056      24125.219      24125.219     -689.78051     -689.78051    
    119000  -8025.0827     -8025.0827     -8112.33       -8112.33        337.65617      337.65617      24141.651      24141.651     -2760.0296     -2760.0296    
Loop time of 105.206 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.67     | 104.67     | 104.67     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097508   | 0.097508   | 0.097508   |   0.0 |  0.09
Output  | 0.00016805 | 0.00016805 | 0.00016805 |   0.0 |  0.00
Modify  | 0.37629    | 0.37629    | 0.37629    |   0.0 |  0.36
Other   |            | 0.06044    |            |       |  0.06

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

Total # of neighbors = 127926
Ave neighs/atom = 63.963
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.787347342733, Press = 0.514120883119158
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    119000  -8025.0827     -8025.0827     -8112.33       -8112.33        337.65617      337.65617      24141.651      24141.651     -2760.0296     -2760.0296    
    120000  -8020.3516     -8020.3516     -8106.7444     -8106.7444      334.349        334.349        24148.781      24148.781     -2640.2062     -2640.2062    
Loop time of 108.272 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.798 ns/day, 30.076 hours/ns, 9.236 timesteps/s
99.9% 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.72     | 107.72     | 107.72     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10072    | 0.10072    | 0.10072    |   0.0 |  0.09
Output  | 0.00016647 | 0.00016647 | 0.00016647 |   0.0 |  0.00
Modify  | 0.38897    | 0.38897    | 0.38897    |   0.0 |  0.36
Other   |            | 0.0619     |            |       |  0.06

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

Total # of neighbors = 127928
Ave neighs/atom = 63.964
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.771946507893, Press = 0.492238305794673
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    120000  -8020.3516     -8020.3516     -8106.7444     -8106.7444      334.349        334.349        24148.781      24148.781     -2640.2062     -2640.2062    
    121000  -8023.4058     -8023.4058     -8108.7719     -8108.7719      330.37585      330.37585      24139.248      24139.248     -2080.0782     -2080.0782    
Loop time of 106.602 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.06     | 106.06     | 106.06     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099871   | 0.099871   | 0.099871   |   0.0 |  0.09
Output  | 0.0001941  | 0.0001941  | 0.0001941  |   0.0 |  0.00
Modify  | 0.38266    | 0.38266    | 0.38266    |   0.0 |  0.36
Other   |            | 0.06066    |            |       |  0.06

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

Total # of neighbors = 127912
Ave neighs/atom = 63.956
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.763336961296, Press = 0.267221591462001
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    121000  -8023.4058     -8023.4058     -8108.7719     -8108.7719      330.37585      330.37585      24139.248      24139.248     -2080.0782     -2080.0782    
    122000  -8022.3169     -8022.3169     -8107.473      -8107.473       329.56299      329.56299      24135.87       24135.87      -1802.3315     -1802.3315    
Loop time of 108.925 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.793 ns/day, 30.257 hours/ns, 9.181 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.37     | 108.37     | 108.37     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10091    | 0.10091    | 0.10091    |   0.0 |  0.09
Output  | 0.00016537 | 0.00016537 | 0.00016537 |   0.0 |  0.00
Modify  | 0.39286    | 0.39286    | 0.39286    |   0.0 |  0.36
Other   |            | 0.0619     |            |       |  0.06

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

Total # of neighbors = 127952
Ave neighs/atom = 63.976
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.782002677618, Press = 0.0399330289224368
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    122000  -8022.3169     -8022.3169     -8107.473      -8107.473       329.56299      329.56299      24135.87       24135.87      -1802.3315     -1802.3315    
    123000  -8022.1188     -8022.1188     -8107.6516     -8107.6516      331.02081      331.02081      24124.919      24124.919     -886.17372     -886.17372    
Loop time of 107.11 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.807 ns/day, 29.753 hours/ns, 9.336 timesteps/s
99.9% 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.56     | 106.56     | 106.56     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099214   | 0.099214   | 0.099214   |   0.0 |  0.09
Output  | 0.00016582 | 0.00016582 | 0.00016582 |   0.0 |  0.00
Modify  | 0.38468    | 0.38468    | 0.38468    |   0.0 |  0.36
Other   |            | 0.06073    |            |       |  0.06

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

Total # of neighbors = 127924
Ave neighs/atom = 63.962
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.783530356286, Press = 0.0152547348543927
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    123000  -8022.1188     -8022.1188     -8107.6516     -8107.6516      331.02081      331.02081      24124.919      24124.919     -886.17372     -886.17372    
    124000  -8017.5351     -8017.5351     -8106.4535     -8106.4535      344.12333      344.12333      24127.83       24127.83      -923.48128     -923.48128    
Loop time of 106.775 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.660 hours/ns, 9.365 timesteps/s
99.9% 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.23     | 106.23     | 106.23     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099995   | 0.099995   | 0.099995   |   0.0 |  0.09
Output  | 0.00021721 | 0.00021721 | 0.00021721 |   0.0 |  0.00
Modify  | 0.38307    | 0.38307    | 0.38307    |   0.0 |  0.36
Other   |            | 0.06134    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.794753236444, Press = -0.060449809296658
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    124000  -8017.5351     -8017.5351     -8106.4535     -8106.4535      344.12333      344.12333      24127.83       24127.83      -923.48128     -923.48128    
    125000  -8022.8774     -8022.8774     -8108.2618     -8108.2618      330.44655      330.44655      24119.66       24119.66      -636.515       -636.515      
Loop time of 108.199 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.799 ns/day, 30.055 hours/ns, 9.242 timesteps/s
99.9% 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.65     | 107.65     | 107.65     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099253   | 0.099253   | 0.099253   |   0.0 |  0.09
Output  | 0.00016639 | 0.00016639 | 0.00016639 |   0.0 |  0.00
Modify  | 0.38624    | 0.38624    | 0.38624    |   0.0 |  0.36
Other   |            | 0.06166    |            |       |  0.06

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

Total # of neighbors = 127916
Ave neighs/atom = 63.958
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.816144427488, Press = -0.193743542296902
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    125000  -8022.8774     -8022.8774     -8108.2618     -8108.2618      330.44655      330.44655      24119.66       24119.66      -636.515       -636.515      
    126000  -8015.0625     -8015.0625     -8105.9436     -8105.9436      351.71934      351.71934      24124.546      24124.546     -324.10325     -324.10325    
Loop time of 107.756 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.802 ns/day, 29.932 hours/ns, 9.280 timesteps/s
99.9% 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.21     | 107.21     | 107.21     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10076    | 0.10076    | 0.10076    |   0.0 |  0.09
Output  | 0.00016605 | 0.00016605 | 0.00016605 |   0.0 |  0.00
Modify  | 0.3879     | 0.3879     | 0.3879     |   0.0 |  0.36
Other   |            | 0.06103    |            |       |  0.06

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

Total # of neighbors = 127962
Ave neighs/atom = 63.981
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.83928046282, Press = -0.341279763962005
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    126000  -8015.0625     -8015.0625     -8105.9436     -8105.9436      351.71934      351.71934      24124.546      24124.546     -324.10325     -324.10325    
    127000  -8022.794      -8022.794      -8108.9431     -8108.9431      333.40574      333.40574      24104.34       24104.34       470.50578      470.50578    
Loop time of 107.119 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.807 ns/day, 29.755 hours/ns, 9.335 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.57     | 106.57     | 106.57     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099748   | 0.099748   | 0.099748   |   0.0 |  0.09
Output  | 0.00016497 | 0.00016497 | 0.00016497 |   0.0 |  0.00
Modify  | 0.38412    | 0.38412    | 0.38412    |   0.0 |  0.36
Other   |            | 0.06125    |            |       |  0.06

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

Total # of neighbors = 127914
Ave neighs/atom = 63.957
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.850666074951, Press = -0.445584911475512
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    127000  -8022.794      -8022.794      -8108.9431     -8108.9431      333.40574      333.40574      24104.34       24104.34       470.50578      470.50578    
    128000  -8019.535      -8019.535      -8106.7187     -8106.7187      337.40993      337.40993      24096.595      24096.595      1432.0392      1432.0392    
Loop time of 107.715 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.802 ns/day, 29.921 hours/ns, 9.284 timesteps/s
99.9% 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.17     | 107.17     | 107.17     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099652   | 0.099652   | 0.099652   |   0.0 |  0.09
Output  | 0.00040126 | 0.00040126 | 0.00040126 |   0.0 |  0.00
Modify  | 0.38576    | 0.38576    | 0.38576    |   0.0 |  0.36
Other   |            | 0.06125    |            |       |  0.06

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

Total # of neighbors = 127932
Ave neighs/atom = 63.966
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.867883757138, Press = -0.39914255958904
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    128000  -8019.535      -8019.535      -8106.7187     -8106.7187      337.40993      337.40993      24096.595      24096.595      1432.0392      1432.0392    
    129000  -8025.2121     -8025.2121     -8110.4358     -8110.4358      329.82452      329.82452      24068.352      24068.352      2894.1337      2894.1337    
Loop time of 105.079 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.189 hours/ns, 9.517 timesteps/s
99.9% 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.55     | 104.55     | 104.55     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097442   | 0.097442   | 0.097442   |   0.0 |  0.09
Output  | 0.00016406 | 0.00016406 | 0.00016406 |   0.0 |  0.00
Modify  | 0.37234    | 0.37234    | 0.37234    |   0.0 |  0.35
Other   |            | 0.06011    |            |       |  0.06

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

Total # of neighbors = 127948
Ave neighs/atom = 63.974
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.863619130917, Press = -0.259916090020972
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    129000  -8025.2121     -8025.2121     -8110.4358     -8110.4358      329.82452      329.82452      24068.352      24068.352      2894.1337      2894.1337    
    130000  -8021.2031     -8021.2031     -8107.3923     -8107.3923      333.56121      333.56121      24070.896      24070.896      3273.2174      3273.2174    
Loop time of 105.267 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.74     | 104.74     | 104.74     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097045   | 0.097045   | 0.097045   |   0.0 |  0.09
Output  | 0.00016427 | 0.00016427 | 0.00016427 |   0.0 |  0.00
Modify  | 0.37267    | 0.37267    | 0.37267    |   0.0 |  0.35
Other   |            | 0.06089    |            |       |  0.06

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

Total # of neighbors = 127956
Ave neighs/atom = 63.978
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.845837075213, Press = 0.0507659720666804
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    130000  -8021.2031     -8021.2031     -8107.3923     -8107.3923      333.56121      333.56121      24070.896      24070.896      3273.2174      3273.2174    
    131000  -8026.8317     -8026.8317     -8110.3432     -8110.3432      323.19807      323.19807      24079.99       24079.99       2114.7723      2114.7723    
Loop time of 105.89 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.414 hours/ns, 9.444 timesteps/s
99.9% 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.35     | 105.35     | 105.35     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099069   | 0.099069   | 0.099069   |   0.0 |  0.09
Output  | 0.00016485 | 0.00016485 | 0.00016485 |   0.0 |  0.00
Modify  | 0.37784    | 0.37784    | 0.37784    |   0.0 |  0.36
Other   |            | 0.06071    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.834560740173, Press = 0.200206248732301
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    131000  -8026.8317     -8026.8317     -8110.3432     -8110.3432      323.19807      323.19807      24079.99       24079.99       2114.7723      2114.7723    
    132000  -8021.0867     -8021.0867     -8106.7244     -8106.7244      331.42658      331.42658      24107.359      24107.359      656.8874       656.8874     
Loop time of 106.195 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.499 hours/ns, 9.417 timesteps/s
99.9% 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.66     | 105.66     | 105.66     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098358   | 0.098358   | 0.098358   |   0.0 |  0.09
Output  | 0.00016702 | 0.00016702 | 0.00016702 |   0.0 |  0.00
Modify  | 0.37777    | 0.37777    | 0.37777    |   0.0 |  0.36
Other   |            | 0.0598     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127942 ave      127942 max      127942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127942
Ave neighs/atom = 63.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.829424527367, Press = 0.193616667034337
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    132000  -8021.0867     -8021.0867     -8106.7244     -8106.7244      331.42658      331.42658      24107.359      24107.359      656.8874       656.8874     
    133000  -8016.2196     -8016.2196     -8107.1806     -8107.1806      352.02864      352.02864      24115.994      24115.994      96.369341      96.369341    
Loop time of 106.613 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.07     | 106.07     | 106.07     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099456   | 0.099456   | 0.099456   |   0.0 |  0.09
Output  | 0.00016577 | 0.00016577 | 0.00016577 |   0.0 |  0.00
Modify  | 0.38233    | 0.38233    | 0.38233    |   0.0 |  0.36
Other   |            | 0.06097    |            |       |  0.06

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

Total # of neighbors = 127934
Ave neighs/atom = 63.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.838899671754, Press = 0.100779155128089
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    133000  -8016.2196     -8016.2196     -8107.1806     -8107.1806      352.02864      352.02864      24115.994      24115.994      96.369341      96.369341    
    134000  -8024.0111     -8024.0111     -8107.1931     -8107.1931      321.92292      321.92292      24118.038      24118.038     -471.60449     -471.60449    
Loop time of 107.2 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.806 ns/day, 29.778 hours/ns, 9.328 timesteps/s
99.9% 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.66     | 106.66     | 106.66     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099063   | 0.099063   | 0.099063   |   0.0 |  0.09
Output  | 0.00016653 | 0.00016653 | 0.00016653 |   0.0 |  0.00
Modify  | 0.38253    | 0.38253    | 0.38253    |   0.0 |  0.36
Other   |            | 0.0609     |            |       |  0.06

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

Total # of neighbors = 127932
Ave neighs/atom = 63.966
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.854353544626, Press = 0.219521230383078
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    134000  -8024.0111     -8024.0111     -8107.1931     -8107.1931      321.92292      321.92292      24118.038      24118.038     -471.60449     -471.60449    
    135000  -8023.4404     -8023.4404     -8108.7676     -8108.7676      330.22515      330.22515      24146.761      24146.761     -2907.6978     -2907.6978    
Loop time of 105.466 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.93     | 104.93     | 104.93     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097599   | 0.097599   | 0.097599   |   0.0 |  0.09
Output  | 0.00016572 | 0.00016572 | 0.00016572 |   0.0 |  0.00
Modify  | 0.37586    | 0.37586    | 0.37586    |   0.0 |  0.36
Other   |            | 0.05963    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.870240430553, Press = 0.383808898931711
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    135000  -8023.4404     -8023.4404     -8108.7676     -8108.7676      330.22515      330.22515      24146.761      24146.761     -2907.6978     -2907.6978    
    136000  -8022.5794     -8022.5794     -8106.3492     -8106.3492      324.19798      324.19798      24152.069      24152.069     -2861.1971     -2861.1971    
Loop time of 104.909 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.141 hours/ns, 9.532 timesteps/s
99.9% 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.38     | 104.38     | 104.38     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098678   | 0.098678   | 0.098678   |   0.0 |  0.09
Output  | 0.00016511 | 0.00016511 | 0.00016511 |   0.0 |  0.00
Modify  | 0.37486    | 0.37486    | 0.37486    |   0.0 |  0.36
Other   |            | 0.06011    |            |       |  0.06

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

Total # of neighbors = 127938
Ave neighs/atom = 63.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.876952062591, Press = 0.135065730099696
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    136000  -8022.5794     -8022.5794     -8106.3492     -8106.3492      324.19798      324.19798      24152.069      24152.069     -2861.1971     -2861.1971    
    137000  -8021.6568     -8021.6568     -8107.8775     -8107.8775      333.68295      333.68295      24142.3        24142.3       -2505.4784     -2505.4784    
Loop time of 105.093 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.56     | 104.56     | 104.56     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098321   | 0.098321   | 0.098321   |   0.0 |  0.09
Output  | 0.00016472 | 0.00016472 | 0.00016472 |   0.0 |  0.00
Modify  | 0.37351    | 0.37351    | 0.37351    |   0.0 |  0.36
Other   |            | 0.06033    |            |       |  0.06

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

Total # of neighbors = 127920
Ave neighs/atom = 63.96
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.872018332942, Press = -0.02987019068263
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    137000  -8021.6568     -8021.6568     -8107.8775     -8107.8775      333.68295      333.68295      24142.3        24142.3       -2505.4784     -2505.4784    
    138000  -8023.0347     -8023.0347     -8107.7648     -8107.7648      327.91405      327.91405      24130.287      24130.287     -1551.9522     -1551.9522    
Loop time of 105.665 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.13     | 105.13     | 105.13     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098789   | 0.098789   | 0.098789   |   0.0 |  0.09
Output  | 0.00026125 | 0.00026125 | 0.00026125 |   0.0 |  0.00
Modify  | 0.37546    | 0.37546    | 0.37546    |   0.0 |  0.36
Other   |            | 0.06036    |            |       |  0.06

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

Total # of neighbors = 127950
Ave neighs/atom = 63.975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.878034103511, Press = -0.156012994465892
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    138000  -8023.0347     -8023.0347     -8107.7648     -8107.7648      327.91405      327.91405      24130.287      24130.287     -1551.9522     -1551.9522    
    139000  -8018.0935     -8018.0935     -8105.1239     -8105.1239      336.81659      336.81659      24126.967      24126.967     -734.29311     -734.29311    
Loop time of 105.792 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.387 hours/ns, 9.453 timesteps/s
99.9% 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.25     | 105.25     | 105.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098691   | 0.098691   | 0.098691   |   0.0 |  0.09
Output  | 0.00016326 | 0.00016326 | 0.00016326 |   0.0 |  0.00
Modify  | 0.37773    | 0.37773    | 0.37773    |   0.0 |  0.36
Other   |            | 0.06085    |            |       |  0.06

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

Total # of neighbors = 127942
Ave neighs/atom = 63.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.895232531334, Press = -0.265565169625713
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    139000  -8018.0935     -8018.0935     -8105.1239     -8105.1239      336.81659      336.81659      24126.967      24126.967     -734.29311     -734.29311    
    140000  -8023.3588     -8023.3588     -8108.4376     -8108.4376      329.26392      329.26392      24110.888      24110.888     -108.47256     -108.47256    
Loop time of 106.304 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.529 hours/ns, 9.407 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.77     | 105.77     | 105.77     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098286   | 0.098286   | 0.098286   |   0.0 |  0.09
Output  | 0.00016433 | 0.00016433 | 0.00016433 |   0.0 |  0.00
Modify  | 0.37953    | 0.37953    | 0.37953    |   0.0 |  0.36
Other   |            | 0.06045    |            |       |  0.06

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

Total # of neighbors = 127962
Ave neighs/atom = 63.981
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.902204108644, Press = -0.12299124032282
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    140000  -8023.3588     -8023.3588     -8108.4376     -8108.4376      329.26392      329.26392      24110.888      24110.888     -108.47256     -108.47256    
    141000  -8020.7837     -8020.7837     -8108.4052     -8108.4052      339.10411      339.10411      24112.182      24112.182      10.584166      10.584166    
Loop time of 106.343 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.8      | 105.8      | 105.8      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098851   | 0.098851   | 0.098851   |   0.0 |  0.09
Output  | 0.0001699  | 0.0001699  | 0.0001699  |   0.0 |  0.00
Modify  | 0.37881    | 0.37881    | 0.37881    |   0.0 |  0.36
Other   |            | 0.06091    |            |       |  0.06

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

Total # of neighbors = 127938
Ave neighs/atom = 63.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.893131628245, Press = -0.138642232249829
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    141000  -8020.7837     -8020.7837     -8108.4052     -8108.4052      339.10411      339.10411      24112.182      24112.182      10.584166      10.584166    
    142000  -8024.8765     -8024.8765     -8109.058      -8109.058       325.79109      325.79109      24111.584      24111.584     -224.30013     -224.30013    
Loop time of 106.119 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.477 hours/ns, 9.423 timesteps/s
99.9% 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.58     | 105.58     | 105.58     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098239   | 0.098239   | 0.098239   |   0.0 |  0.09
Output  | 0.00020074 | 0.00020074 | 0.00020074 |   0.0 |  0.00
Modify  | 0.37756    | 0.37756    | 0.37756    |   0.0 |  0.36
Other   |            | 0.06052    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.879525195655, Press = -0.141169461667885
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    142000  -8024.8765     -8024.8765     -8109.058      -8109.058       325.79109      325.79109      24111.584      24111.584     -224.30013     -224.30013    
    143000  -8021.0384     -8021.0384     -8107.081      -8107.081       332.9937       332.9937       24116.485      24116.485     -234.60163     -234.60163    
Loop time of 105.804 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.390 hours/ns, 9.451 timesteps/s
99.9% 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.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097847   | 0.097847   | 0.097847   |   0.0 |  0.09
Output  | 0.00016516 | 0.00016516 | 0.00016516 |   0.0 |  0.00
Modify  | 0.37862    | 0.37862    | 0.37862    |   0.0 |  0.36
Other   |            | 0.06118    |            |       |  0.06

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

Total # of neighbors = 127960
Ave neighs/atom = 63.98
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.8823787644, Press = -0.13748570900501
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    143000  -8021.0384     -8021.0384     -8107.081      -8107.081       332.9937       332.9937       24116.485      24116.485     -234.60163     -234.60163    
    144000  -8019.5764     -8019.5764     -8104.8841     -8104.8841      330.1495       330.1495       24113.591      24113.591      250.75801      250.75801    
Loop time of 105.593 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.06     | 105.06     | 105.06     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09846    | 0.09846    | 0.09846    |   0.0 |  0.09
Output  | 0.00016584 | 0.00016584 | 0.00016584 |   0.0 |  0.00
Modify  | 0.3775     | 0.3775     | 0.3775     |   0.0 |  0.36
Other   |            | 0.06093    |            |       |  0.06

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

Total # of neighbors = 127930
Ave neighs/atom = 63.965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.891058053146, Press = -0.011285889456504
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    144000  -8019.5764     -8019.5764     -8104.8841     -8104.8841      330.1495       330.1495       24113.591      24113.591      250.75801      250.75801    
    145000  -8023.9613     -8023.9613     -8110.0369     -8110.0369      333.12135      333.12135      24114.22       24114.22      -424.69481     -424.69481    
Loop time of 106.645 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.1      | 106.1      | 106.1      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099742   | 0.099742   | 0.099742   |   0.0 |  0.09
Output  | 0.00016477 | 0.00016477 | 0.00016477 |   0.0 |  0.00
Modify  | 0.38382    | 0.38382    | 0.38382    |   0.0 |  0.36
Other   |            | 0.06039    |            |       |  0.06

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

Total # of neighbors = 127928
Ave neighs/atom = 63.964
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.913464180154, Press = 0.101208235053843
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    145000  -8023.9613     -8023.9613     -8110.0369     -8110.0369      333.12135      333.12135      24114.22       24114.22      -424.69481     -424.69481    
    146000  -8020.22       -8020.22       -8105.3619     -8105.3619      329.50806      329.50806      24131.392      24131.392     -1199.3611     -1199.3611    
Loop time of 106.293 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.526 hours/ns, 9.408 timesteps/s
99.9% 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.75     | 105.75     | 105.75     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098189   | 0.098189   | 0.098189   |   0.0 |  0.09
Output  | 0.00016681 | 0.00016681 | 0.00016681 |   0.0 |  0.00
Modify  | 0.38001    | 0.38001    | 0.38001    |   0.0 |  0.36
Other   |            | 0.05977    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.920315196229, Press = 0.16425907901121
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    146000  -8020.22       -8020.22       -8105.3619     -8105.3619      329.50806      329.50806      24131.392      24131.392     -1199.3611     -1199.3611    
    147000  -8024.8163     -8024.8163     -8108.9392     -8108.9392      325.56465      325.56465      24141.168      24141.168     -2493.896      -2493.896     
Loop time of 106.389 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.85     | 105.85     | 105.85     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098904   | 0.098904   | 0.098904   |   0.0 |  0.09
Output  | 0.00030426 | 0.00030426 | 0.00030426 |   0.0 |  0.00
Modify  | 0.38071    | 0.38071    | 0.38071    |   0.0 |  0.36
Other   |            | 0.06132    |            |       |  0.06

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

Total # of neighbors = 127916
Ave neighs/atom = 63.958
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.922935892915, Press = 0.132563395370695
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    147000  -8024.8163     -8024.8163     -8108.9392     -8108.9392      325.56465      325.56465      24141.168      24141.168     -2493.896      -2493.896     
    148000  -8021.001      -8021.001      -8108.4707     -8108.4707      338.5169       338.5169       24160.409      24160.409     -3643.7788     -3643.7788    
Loop time of 106.567 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.602 hours/ns, 9.384 timesteps/s
99.9% 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.02     | 106.02     | 106.02     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099009   | 0.099009   | 0.099009   |   0.0 |  0.09
Output  | 0.00020891 | 0.00020891 | 0.00020891 |   0.0 |  0.00
Modify  | 0.38117    | 0.38117    | 0.38117    |   0.0 |  0.36
Other   |            | 0.0612     |            |       |  0.06

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

Total # of neighbors = 127944
Ave neighs/atom = 63.972
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.910740067374, Press = -0.0253010618966631
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    148000  -8021.001      -8021.001      -8108.4707     -8108.4707      338.5169       338.5169       24160.409      24160.409     -3643.7788     -3643.7788    
    149000  -8025.5297     -8025.5297     -8110.0192     -8110.0192      326.98314      326.98314      24138.434      24138.434     -2328.3729     -2328.3729    
Loop time of 105.517 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.98     | 104.98     | 104.98     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098343   | 0.098343   | 0.098343   |   0.0 |  0.09
Output  | 0.00016436 | 0.00016436 | 0.00016436 |   0.0 |  0.00
Modify  | 0.37407    | 0.37407    | 0.37407    |   0.0 |  0.35
Other   |            | 0.06064    |            |       |  0.06

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

Total # of neighbors = 127906
Ave neighs/atom = 63.953
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.898223835212, Press = -0.203929807903955
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    149000  -8025.5297     -8025.5297     -8110.0192     -8110.0192      326.98314      326.98314      24138.434      24138.434     -2328.3729     -2328.3729    
    150000  -8022.6785     -8022.6785     -8108.4688     -8108.4688      332.01707      332.01707      24122.945      24122.945     -1002.7449     -1002.7449    
Loop time of 107.354 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.805 ns/day, 29.820 hours/ns, 9.315 timesteps/s
99.9% 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.81     | 106.81     | 106.81     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099568   | 0.099568   | 0.099568   |   0.0 |  0.09
Output  | 0.00016476 | 0.00016476 | 0.00016476 |   0.0 |  0.00
Modify  | 0.38449    | 0.38449    | 0.38449    |   0.0 |  0.36
Other   |            | 0.06092    |            |       |  0.06

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

Total # of neighbors = 127948
Ave neighs/atom = 63.974
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.908591037036, Press = -0.274174310005596
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    150000  -8022.6785     -8022.6785     -8108.4688     -8108.4688      332.01707      332.01707      24122.945      24122.945     -1002.7449     -1002.7449    
    151000  -8025.0198     -8025.0198     -8109.2973     -8109.2973      326.16279      326.16279      24117.068      24117.068     -566.00345     -566.00345    
Loop time of 106.295 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.813 ns/day, 29.526 hours/ns, 9.408 timesteps/s
99.9% 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.76     | 105.76     | 105.76     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09848    | 0.09848    | 0.09848    |   0.0 |  0.09
Output  | 0.00020084 | 0.00020084 | 0.00020084 |   0.0 |  0.00
Modify  | 0.37728    | 0.37728    | 0.37728    |   0.0 |  0.35
Other   |            | 0.06087    |            |       |  0.06

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

Total # of neighbors = 127938
Ave neighs/atom = 63.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.913700068824, Press = -0.2355571843862
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    151000  -8025.0198     -8025.0198     -8109.2973     -8109.2973      326.16279      326.16279      24117.068      24117.068     -566.00345     -566.00345    
    152000  -8020.3253     -8020.3253     -8108.0605     -8108.0605      339.54394      339.54394      24127.153      24127.153     -1104.6007     -1104.6007    
Loop time of 106.526 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.590 hours/ns, 9.387 timesteps/s
99.9% 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.99     | 105.99     | 105.99     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098592   | 0.098592   | 0.098592   |   0.0 |  0.09
Output  | 0.00016387 | 0.00016387 | 0.00016387 |   0.0 |  0.00
Modify  | 0.38023    | 0.38023    | 0.38023    |   0.0 |  0.36
Other   |            | 0.06026    |            |       |  0.06

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

Total # of neighbors = 127934
Ave neighs/atom = 63.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.906443217396, Press = -0.335463037722354
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    152000  -8020.3253     -8020.3253     -8108.0605     -8108.0605      339.54394      339.54394      24127.153      24127.153     -1104.6007     -1104.6007    
    153000  -8025.0295     -8025.0295     -8107.3957     -8107.3957      318.76594      318.76594      24119.045      24119.045     -600.88991     -600.88991    
Loop time of 108.797 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.794 ns/day, 30.221 hours/ns, 9.191 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.24     | 108.24     | 108.24     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10066    | 0.10066    | 0.10066    |   0.0 |  0.09
Output  | 0.00016427 | 0.00016427 | 0.00016427 |   0.0 |  0.00
Modify  | 0.39018    | 0.39018    | 0.39018    |   0.0 |  0.36
Other   |            | 0.06109    |            |       |  0.06

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

Total # of neighbors = 127958
Ave neighs/atom = 63.979
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.896380335102, Press = -0.742805689081822
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    153000  -8025.0295     -8025.0295     -8107.3957     -8107.3957      318.76594      318.76594      24119.045      24119.045     -600.88991     -600.88991    
    154000  -8022.4757     -8022.4757     -8107.5916     -8107.5916      329.4075       329.4075       24101.598      24101.598      771.61172      771.61172    
Loop time of 106.664 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.629 hours/ns, 9.375 timesteps/s
99.9% 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.12     | 106.12     | 106.12     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099069   | 0.099069   | 0.099069   |   0.0 |  0.09
Output  | 0.00020988 | 0.00020988 | 0.00020988 |   0.0 |  0.00
Modify  | 0.38207    | 0.38207    | 0.38207    |   0.0 |  0.36
Other   |            | 0.06112    |            |       |  0.06

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

Total # of neighbors = 127932
Ave neighs/atom = 63.966
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.893424515737, Press = -0.802112128881137
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    154000  -8022.4757     -8022.4757     -8107.5916     -8107.5916      329.4075       329.4075       24101.598      24101.598      771.61172      771.61172    
    155000  -8024.1261     -8024.1261     -8109.0764     -8109.0764      328.76659      328.76659      24094.166      24094.166      1145.2147      1145.2147    
Loop time of 106.67 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.631 hours/ns, 9.375 timesteps/s
99.9% 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.12     | 106.12     | 106.12     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099898   | 0.099898   | 0.099898   |   0.0 |  0.09
Output  | 0.00022658 | 0.00022658 | 0.00022658 |   0.0 |  0.00
Modify  | 0.38481    | 0.38481    | 0.38481    |   0.0 |  0.36
Other   |            | 0.06088    |            |       |  0.06

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

Total # of neighbors = 127954
Ave neighs/atom = 63.977
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.890996178979, Press = -0.520492428700104
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    155000  -8024.1261     -8024.1261     -8109.0764     -8109.0764      328.76659      328.76659      24094.166      24094.166      1145.2147      1145.2147    
    156000  -8021.8824     -8021.8824     -8107.4755     -8107.4755      331.25445      331.25445      24091.486      24091.486      1596.1902      1596.1902    
Loop time of 107.126 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.807 ns/day, 29.757 hours/ns, 9.335 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.58     | 106.58     | 106.58     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099874   | 0.099874   | 0.099874   |   0.0 |  0.09
Output  | 0.00016544 | 0.00016544 | 0.00016544 |   0.0 |  0.00
Modify  | 0.38619    | 0.38619    | 0.38619    |   0.0 |  0.36
Other   |            | 0.06192    |            |       |  0.06

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

Total # of neighbors = 127968
Ave neighs/atom = 63.984
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.870065548071, Press = -0.346461448098383
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    156000  -8021.8824     -8021.8824     -8107.4755     -8107.4755      331.25445      331.25445      24091.486      24091.486      1596.1902      1596.1902    
    157000  -8020.8371     -8020.8371     -8108.3493     -8108.3493      338.68149      338.68149      24088.37       24088.37       1826.978       1826.978     
Loop time of 105.185 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.65     | 104.65     | 104.65     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098464   | 0.098464   | 0.098464   |   0.0 |  0.09
Output  | 0.00016498 | 0.00016498 | 0.00016498 |   0.0 |  0.00
Modify  | 0.37524    | 0.37524    | 0.37524    |   0.0 |  0.36
Other   |            | 0.05997    |            |       |  0.06

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

Total # of neighbors = 127936
Ave neighs/atom = 63.968
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.874299580303, Press = -0.300187412744638
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    157000  -8020.8371     -8020.8371     -8108.3493     -8108.3493      338.68149      338.68149      24088.37       24088.37       1826.978       1826.978     
    158000  -8021.1187     -8021.1187     -8107.6291     -8107.6291      334.80434      334.80434      24075.779      24075.779      2797.8708      2797.8708    
Loop time of 107.734 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.802 ns/day, 29.926 hours/ns, 9.282 timesteps/s
99.9% 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.18     | 107.18     | 107.18     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099729   | 0.099729   | 0.099729   |   0.0 |  0.09
Output  | 0.00016403 | 0.00016403 | 0.00016403 |   0.0 |  0.00
Modify  | 0.38788    | 0.38788    | 0.38788    |   0.0 |  0.36
Other   |            | 0.06102    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.864169181215, Press = -0.179751459585938
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    158000  -8021.1187     -8021.1187     -8107.6291     -8107.6291      334.80434      334.80434      24075.779      24075.779      2797.8708      2797.8708    
    159000  -8022.3849     -8022.3849     -8110.61       -8110.61        341.44037      341.44037      24043.951      24043.951      5075.6587      5075.6587    
Loop time of 106.921 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.700 hours/ns, 9.353 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.38     | 106.38     | 106.38     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09883    | 0.09883    | 0.09883    |   0.0 |  0.09
Output  | 0.0001643  | 0.0001643  | 0.0001643  |   0.0 |  0.00
Modify  | 0.38282    | 0.38282    | 0.38282    |   0.0 |  0.36
Other   |            | 0.06152    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127944 ave      127944 max      127944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127944
Ave neighs/atom = 63.972
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.856207014792, Press = 0.247879498507924
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    159000  -8022.3849     -8022.3849     -8110.61       -8110.61        341.44037      341.44037      24043.951      24043.951      5075.6587      5075.6587    
    160000  -8020.6513     -8020.6513     -8107.7373     -8107.7373      337.03202      337.03202      24068.934      24068.934      3442.4439      3442.4439    
Loop time of 107.596 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.803 ns/day, 29.888 hours/ns, 9.294 timesteps/s
99.9% 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.05     | 107.05     | 107.05     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099918   | 0.099918   | 0.099918   |   0.0 |  0.09
Output  | 0.00020318 | 0.00020318 | 0.00020318 |   0.0 |  0.00
Modify  | 0.38589    | 0.38589    | 0.38589    |   0.0 |  0.36
Other   |            | 0.06147    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127972 ave      127972 max      127972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127972
Ave neighs/atom = 63.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.843891506861, Press = 0.470452539774047
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    160000  -8020.6513     -8020.6513     -8107.7373     -8107.7373      337.03202      337.03202      24068.934      24068.934      3442.4439      3442.4439    
    161000  -8026.5117     -8026.5117     -8109.8103     -8109.8103      322.37392      322.37392      24090.742      24090.742      1247.5165      1247.5165    
Loop time of 108.046 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.800 ns/day, 30.013 hours/ns, 9.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    | 107.5      | 107.5      | 107.5      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10061    | 0.10061    | 0.10061    |   0.0 |  0.09
Output  | 0.00016719 | 0.00016719 | 0.00016719 |   0.0 |  0.00
Modify  | 0.38885    | 0.38885    | 0.38885    |   0.0 |  0.36
Other   |            | 0.06112    |            |       |  0.06

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

Total # of neighbors = 127954
Ave neighs/atom = 63.977
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.83941582815, Press = 0.237161720982085
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    161000  -8026.5117     -8026.5117     -8109.8103     -8109.8103      322.37392      322.37392      24090.742      24090.742      1247.5165      1247.5165    
    162000  -8021.7607     -8021.7607     -8106.8481     -8106.8481      329.29682      329.29682      24103.33       24103.33       659.48677      659.48677    
Loop time of 107.406 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.835 hours/ns, 9.310 timesteps/s
99.9% 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.86     | 106.86     | 106.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09929    | 0.09929    | 0.09929    |   0.0 |  0.09
Output  | 0.00016265 | 0.00016265 | 0.00016265 |   0.0 |  0.00
Modify  | 0.38744    | 0.38744    | 0.38744    |   0.0 |  0.36
Other   |            | 0.06099    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.822996394593, Press = 0.240236232539146
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    162000  -8021.7607     -8021.7607     -8106.8481     -8106.8481      329.29682      329.29682      24103.33       24103.33       659.48677      659.48677    
    163000  -8022.929      -8022.929      -8108.0394     -8108.0394      329.38608      329.38608      24109.981      24109.981      53.029804      53.029804    
Loop time of 105.812 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.392 hours/ns, 9.451 timesteps/s
99.9% 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.28     | 105.28     | 105.28     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098481   | 0.098481   | 0.098481   |   0.0 |  0.09
Output  | 0.00026509 | 0.00026509 | 0.00026509 |   0.0 |  0.00
Modify  | 0.37518    | 0.37518    | 0.37518    |   0.0 |  0.35
Other   |            | 0.06011    |            |       |  0.06

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

Total # of neighbors = 127926
Ave neighs/atom = 63.963
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.829914466079, Press = 0.216728903686633
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    163000  -8022.929      -8022.929      -8108.0394     -8108.0394      329.38608      329.38608      24109.981      24109.981      53.029804      53.029804    
    164000  -8021.4594     -8021.4594     -8106.3562     -8106.3562      328.55934      328.55934      24127.466      24127.466     -1038.9271     -1038.9271    
Loop time of 106.928 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.702 hours/ns, 9.352 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.39     | 106.39     | 106.39     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097849   | 0.097849   | 0.097849   |   0.0 |  0.09
Output  | 0.00020521 | 0.00020521 | 0.00020521 |   0.0 |  0.00
Modify  | 0.38289    | 0.38289    | 0.38289    |   0.0 |  0.36
Other   |            | 0.06108    |            |       |  0.06

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

Total # of neighbors = 127942
Ave neighs/atom = 63.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.829551159041, Press = 0.353886137526514
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    164000  -8021.4594     -8021.4594     -8106.3562     -8106.3562      328.55934      328.55934      24127.466      24127.466     -1038.9271     -1038.9271    
    165000  -8022.4375     -8022.4375     -8108.2871     -8108.2871      332.24671      332.24671      24151.307      24151.307     -3105.6498     -3105.6498    
Loop time of 107.946 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.800 ns/day, 29.985 hours/ns, 9.264 timesteps/s
99.9% 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.4      | 107.4      | 107.4      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099304   | 0.099304   | 0.099304   |   0.0 |  0.09
Output  | 0.00016638 | 0.00016638 | 0.00016638 |   0.0 |  0.00
Modify  | 0.3865     | 0.3865     | 0.3865     |   0.0 |  0.36
Other   |            | 0.0615     |            |       |  0.06

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

Total # of neighbors = 127892
Ave neighs/atom = 63.946
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.83081876492, Press = 0.537100006528087
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    165000  -8022.4375     -8022.4375     -8108.2871     -8108.2871      332.24671      332.24671      24151.307      24151.307     -3105.6498     -3105.6498    
    166000  -8021.2426     -8021.2426     -8108.4246     -8108.4246      337.4032       337.4032       24150.745      24150.745     -2907.3535     -2907.3535    
Loop time of 106.479 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.577 hours/ns, 9.392 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.94     | 105.94     | 105.94     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098022   | 0.098022   | 0.098022   |   0.0 |  0.09
Output  | 0.00039456 | 0.00039456 | 0.00039456 |   0.0 |  0.00
Modify  | 0.3806     | 0.3806     | 0.3806     |   0.0 |  0.36
Other   |            | 0.06039    |            |       |  0.06

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

Total # of neighbors = 127942
Ave neighs/atom = 63.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.824983191234, Press = 0.269488176774204
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    166000  -8021.2426     -8021.2426     -8108.4246     -8108.4246      337.4032       337.4032       24150.745      24150.745     -2907.3535     -2907.3535    
    167000  -8024.0227     -8024.0227     -8109.3909     -8109.3909      330.3837       330.3837       24142.983      24142.983     -2692.183      -2692.183     
Loop time of 107.114 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.807 ns/day, 29.754 hours/ns, 9.336 timesteps/s
99.9% 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.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098795   | 0.098795   | 0.098795   |   0.0 |  0.09
Output  | 0.00016704 | 0.00016704 | 0.00016704 |   0.0 |  0.00
Modify  | 0.38477    | 0.38477    | 0.38477    |   0.0 |  0.36
Other   |            | 0.06107    |            |       |  0.06

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

Total # of neighbors = 127942
Ave neighs/atom = 63.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.817959719539, Press = 0.0330137958264104
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    167000  -8024.0227     -8024.0227     -8109.3909     -8109.3909      330.3837       330.3837       24142.983      24142.983     -2692.183      -2692.183     
    168000  -8020.3266     -8020.3266     -8106.2091     -8106.2091      332.37428      332.37428      24146.565      24146.565     -2397.9016     -2397.9016    
Loop time of 107.425 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.840 hours/ns, 9.309 timesteps/s
99.9% 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.88     | 106.88     | 106.88     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1001     | 0.1001     | 0.1001     |   0.0 |  0.09
Output  | 0.0001637  | 0.0001637  | 0.0001637  |   0.0 |  0.00
Modify  | 0.38711    | 0.38711    | 0.38711    |   0.0 |  0.36
Other   |            | 0.06064    |            |       |  0.06

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

Total # of neighbors = 127920
Ave neighs/atom = 63.96
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.802828246105, Press = -0.0999215799261472
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    168000  -8020.3266     -8020.3266     -8106.2091     -8106.2091      332.37428      332.37428      24146.565      24146.565     -2397.9016     -2397.9016    
    169000  -8022.9942     -8022.9942     -8109.4965     -8109.4965      334.77292      334.77292      24139.058      24139.058     -2153.2654     -2153.2654    
Loop time of 107.23 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.806 ns/day, 29.786 hours/ns, 9.326 timesteps/s
99.9% 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.69     | 106.69     | 106.69     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098972   | 0.098972   | 0.098972   |   0.0 |  0.09
Output  | 0.00016613 | 0.00016613 | 0.00016613 |   0.0 |  0.00
Modify  | 0.38392    | 0.38392    | 0.38392    |   0.0 |  0.36
Other   |            | 0.06128    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4113 ave        4113 max        4113 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127896 ave      127896 max      127896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127896
Ave neighs/atom = 63.948
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.807889250826, Press = -0.184092698495774
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    169000  -8022.9942     -8022.9942     -8109.4965     -8109.4965      334.77292      334.77292      24139.058      24139.058     -2153.2654     -2153.2654    
    170000  -8019.1862     -8019.1862     -8107.8946     -8107.8946      343.31091      343.31091      24145.807      24145.807     -2432.1703     -2432.1703    
Loop time of 107.798 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.801 ns/day, 29.944 hours/ns, 9.277 timesteps/s
99.9% 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.25     | 107.25     | 107.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099527   | 0.099527   | 0.099527   |   0.0 |  0.09
Output  | 0.00016538 | 0.00016538 | 0.00016538 |   0.0 |  0.00
Modify  | 0.38482    | 0.38482    | 0.38482    |   0.0 |  0.36
Other   |            | 0.06099    |            |       |  0.06

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

Total # of neighbors = 127928
Ave neighs/atom = 63.964
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.818778052844, Press = -0.334542071786467
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    170000  -8019.1862     -8019.1862     -8107.8946     -8107.8946      343.31091      343.31091      24145.807      24145.807     -2432.1703     -2432.1703    
    171000  -8023.3187     -8023.3187     -8107.7724     -8107.7724      326.84455      326.84455      24155.748      24155.748     -3362.2718     -3362.2718    
Loop time of 108.166 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.799 ns/day, 30.046 hours/ns, 9.245 timesteps/s
99.9% 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.61     | 107.61     | 107.61     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09996    | 0.09996    | 0.09996    |   0.0 |  0.09
Output  | 0.00016744 | 0.00016744 | 0.00016744 |   0.0 |  0.00
Modify  | 0.39109    | 0.39109    | 0.39109    |   0.0 |  0.36
Other   |            | 0.06173    |            |       |  0.06

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

Total # of neighbors = 127916
Ave neighs/atom = 63.958
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.816736960374, Press = -0.813067029348597
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    171000  -8023.3187     -8023.3187     -8107.7724     -8107.7724      326.84455      326.84455      24155.748      24155.748     -3362.2718     -3362.2718    
    172000  -8019.7601     -8019.7601     -8106.5936     -8106.5936      336.05466      336.05466      24127.871      24127.871     -977.54629     -977.54629    
Loop time of 108.3 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.798 ns/day, 30.083 hours/ns, 9.234 timesteps/s
99.9% 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.75     | 107.75     | 107.75     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099114   | 0.099114   | 0.099114   |   0.0 |  0.09
Output  | 0.00016451 | 0.00016451 | 0.00016451 |   0.0 |  0.00
Modify  | 0.38665    | 0.38665    | 0.38665    |   0.0 |  0.36
Other   |            | 0.061      |            |       |  0.06

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

Total # of neighbors = 127914
Ave neighs/atom = 63.957
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.816309425891, Press = -0.371892496480922
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    172000  -8019.7601     -8019.7601     -8106.5936     -8106.5936      336.05466      336.05466      24127.871      24127.871     -977.54629     -977.54629    
    173000  -8024.6208     -8024.6208     -8107.9926     -8107.9926      322.65732      322.65732      24104.602      24104.602      442.96531      442.96531    
Loop time of 107.294 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.805 ns/day, 29.804 hours/ns, 9.320 timesteps/s
99.9% 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.75     | 106.75     | 106.75     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098665   | 0.098665   | 0.098665   |   0.0 |  0.09
Output  | 0.00016592 | 0.00016592 | 0.00016592 |   0.0 |  0.00
Modify  | 0.38345    | 0.38345    | 0.38345    |   0.0 |  0.36
Other   |            | 0.06076    |            |       |  0.06

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

Total # of neighbors = 127916
Ave neighs/atom = 63.958
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.800562339176, Press = -0.251648311327357
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    173000  -8024.6208     -8024.6208     -8107.9926     -8107.9926      322.65732      322.65732      24104.602      24104.602      442.96531      442.96531    
    174000  -8020.2355     -8020.2355     -8106.1109     -8106.1109      332.3468       332.3468       24114.027      24114.027      166.75121      166.75121    
Loop time of 106.159 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.489 hours/ns, 9.420 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.62     | 105.62     | 105.62     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097656   | 0.097656   | 0.097656   |   0.0 |  0.09
Output  | 0.00016567 | 0.00016567 | 0.00016567 |   0.0 |  0.00
Modify  | 0.37834    | 0.37834    | 0.37834    |   0.0 |  0.36
Other   |            | 0.06052    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127946 ave      127946 max      127946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127946
Ave neighs/atom = 63.973
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.803091380744, Press = -0.191908705802107
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    174000  -8020.2355     -8020.2355     -8106.1109     -8106.1109      332.3468       332.3468       24114.027      24114.027      166.75121      166.75121    
    175000  -8022.1039     -8022.1039     -8107.9061     -8107.9061      332.06336      332.06336      24113.791      24113.791     -193.19554     -193.19554    
Loop time of 106.903 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.695 hours/ns, 9.354 timesteps/s
99.9% 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.36     | 106.36     | 106.36     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098964   | 0.098964   | 0.098964   |   0.0 |  0.09
Output  | 0.00020192 | 0.00020192 | 0.00020192 |   0.0 |  0.00
Modify  | 0.38334    | 0.38334    | 0.38334    |   0.0 |  0.36
Other   |            | 0.06085    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127944 ave      127944 max      127944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127944
Ave neighs/atom = 63.972
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.788935630671, Press = -0.350563119427514
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    175000  -8022.1039     -8022.1039     -8107.9061     -8107.9061      332.06336      332.06336      24113.791      24113.791     -193.19554     -193.19554    
    176000  -8026.1965     -8026.1965     -8110.8986     -8110.8986      327.80594      327.80594      24101.389      24101.389      320.22939      320.22939    
Loop time of 106.68 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.14     | 106.14     | 106.14     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099629   | 0.099629   | 0.099629   |   0.0 |  0.09
Output  | 0.00016469 | 0.00016469 | 0.00016469 |   0.0 |  0.00
Modify  | 0.38342    | 0.38342    | 0.38342    |   0.0 |  0.36
Other   |            | 0.06078    |            |       |  0.06

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

Total # of neighbors = 127928
Ave neighs/atom = 63.964
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.774916726416, Press = -0.707185941073141
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    176000  -8026.1965     -8026.1965     -8110.8986     -8110.8986      327.80594      327.80594      24101.389      24101.389      320.22939      320.22939    
    177000  -8021.1314     -8021.1314     -8107.3043     -8107.3043      333.49799      333.49799      24095.808      24095.808      1342.5791      1342.5791    
Loop time of 105.317 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.255 hours/ns, 9.495 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.78     | 104.78     | 104.78     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097994   | 0.097994   | 0.097994   |   0.0 |  0.09
Output  | 0.0001644  | 0.0001644  | 0.0001644  |   0.0 |  0.00
Modify  | 0.37616    | 0.37616    | 0.37616    |   0.0 |  0.36
Other   |            | 0.05978    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127944 ave      127944 max      127944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127944
Ave neighs/atom = 63.972
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.772265250019, Press = -0.444508823947254
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    177000  -8021.1314     -8021.1314     -8107.3043     -8107.3043      333.49799      333.49799      24095.808      24095.808      1342.5791      1342.5791    
    178000  -8022.6493     -8022.6493     -8107.2074     -8107.2074      327.24888      327.24888      24094.187      24094.187      1360.2839      1360.2839    
Loop time of 106.68 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.14     | 106.14     | 106.14     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099314   | 0.099314   | 0.099314   |   0.0 |  0.09
Output  | 0.00016431 | 0.00016431 | 0.00016431 |   0.0 |  0.00
Modify  | 0.37816    | 0.37816    | 0.37816    |   0.0 |  0.35
Other   |            | 0.06088    |            |       |  0.06

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

Total # of neighbors = 127966
Ave neighs/atom = 63.983
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.764364733278, Press = -0.185222764500276
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    178000  -8022.6493     -8022.6493     -8107.2074     -8107.2074      327.24888      327.24888      24094.187      24094.187      1360.2839      1360.2839    
    179000  -8022.9197     -8022.9197     -8108.0815     -8108.0815      329.58515      329.58515      24089.051      24089.051      1632.5189      1632.5189    
Loop time of 106.498 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.583 hours/ns, 9.390 timesteps/s
99.9% 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.96     | 105.96     | 105.96     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098962   | 0.098962   | 0.098962   |   0.0 |  0.09
Output  | 0.00016782 | 0.00016782 | 0.00016782 |   0.0 |  0.00
Modify  | 0.37931    | 0.37931    | 0.37931    |   0.0 |  0.36
Other   |            | 0.06063    |            |       |  0.06

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

Total # of neighbors = 127936
Ave neighs/atom = 63.968
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.765719675793, Press = -0.172964949753397
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    179000  -8022.9197     -8022.9197     -8108.0815     -8108.0815      329.58515      329.58515      24089.051      24089.051      1632.5189      1632.5189    
    180000  -8024.9137     -8024.9137     -8107.3888     -8107.3888      319.187        319.187        24075.517      24075.517      2733.1814      2733.1814    
Loop time of 106.206 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.502 hours/ns, 9.416 timesteps/s
99.9% 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.67     | 105.67     | 105.67     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098895   | 0.098895   | 0.098895   |   0.0 |  0.09
Output  | 0.00016493 | 0.00016493 | 0.00016493 |   0.0 |  0.00
Modify  | 0.37832    | 0.37832    | 0.37832    |   0.0 |  0.36
Other   |            | 0.06054    |            |       |  0.06

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

Total # of neighbors = 127968
Ave neighs/atom = 63.984
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.746338168812, Press = -0.0365442119532207
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    180000  -8024.9137     -8024.9137     -8107.3888     -8107.3888      319.187        319.187        24075.517      24075.517      2733.1814      2733.1814    
    181000  -8020.5243     -8020.5243     -8108.3294     -8108.3294      339.81496      339.81496      24051.417      24051.417      4647.0874      4647.0874    
Loop time of 106.045 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.457 hours/ns, 9.430 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.51     | 105.51     | 105.51     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097593   | 0.097593   | 0.097593   |   0.0 |  0.09
Output  | 0.0001644  | 0.0001644  | 0.0001644  |   0.0 |  0.00
Modify  | 0.37912    | 0.37912    | 0.37912    |   0.0 |  0.36
Other   |            | 0.06071    |            |       |  0.06

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

Total # of neighbors = 127958
Ave neighs/atom = 63.979
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.745710855351, Press = 0.153799371755755
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    181000  -8020.5243     -8020.5243     -8108.3294     -8108.3294      339.81496      339.81496      24051.417      24051.417      4647.0874      4647.0874    
    182000  -8017.7737     -8017.7737     -8107.2463     -8107.2463      346.26837      346.26837      24068.392      24068.392      3562.2859      3562.2859    
Loop time of 106.941 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.808 ns/day, 29.706 hours/ns, 9.351 timesteps/s
99.9% 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.4      | 106.4      | 106.4      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098494   | 0.098494   | 0.098494   |   0.0 |  0.09
Output  | 0.00016348 | 0.00016348 | 0.00016348 |   0.0 |  0.00
Modify  | 0.38291    | 0.38291    | 0.38291    |   0.0 |  0.36
Other   |            | 0.06047    |            |       |  0.06

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

Total # of neighbors = 127948
Ave neighs/atom = 63.974
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.752921688277, Press = 0.323626811384313
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    182000  -8017.7737     -8017.7737     -8107.2463     -8107.2463      346.26837      346.26837      24068.392      24068.392      3562.2859      3562.2859    
    183000  -8023.5067     -8023.5067     -8109.6481     -8109.6481      333.37628      333.37628      24088.955      24088.955      1525.5679      1525.5679    
Loop time of 107.605 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.803 ns/day, 29.890 hours/ns, 9.293 timesteps/s
99.9% 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.05     | 107.05     | 107.05     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10031    | 0.10031    | 0.10031    |   0.0 |  0.09
Output  | 0.00029068 | 0.00029068 | 0.00029068 |   0.0 |  0.00
Modify  | 0.38923    | 0.38923    | 0.38923    |   0.0 |  0.36
Other   |            | 0.06137    |            |       |  0.06

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

Total # of neighbors = 127958
Ave neighs/atom = 63.979
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.76849936992, Press = 0.276976146011376
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    183000  -8023.5067     -8023.5067     -8109.6481     -8109.6481      333.37628      333.37628      24088.955      24088.955      1525.5679      1525.5679    
    184000  -8018.798      -8018.798      -8105.5459     -8105.5459      335.72325      335.72325      24104.549      24104.549      848.79813      848.79813    
Loop time of 106.628 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.09     | 106.09     | 106.09     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099404   | 0.099404   | 0.099404   |   0.0 |  0.09
Output  | 0.00020638 | 0.00020638 | 0.00020638 |   0.0 |  0.00
Modify  | 0.38203    | 0.38203    | 0.38203    |   0.0 |  0.36
Other   |            | 0.06047    |            |       |  0.06

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

Total # of neighbors = 127958
Ave neighs/atom = 63.979
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.779055459948, Press = 0.287393890947765
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    184000  -8018.798      -8018.798      -8105.5459     -8105.5459      335.72325      335.72325      24104.549      24104.549      848.79813      848.79813    
    185000  -8023.6262     -8023.6262     -8108.8825     -8108.8825      329.95089      329.95089      24111.386      24111.386     -136.40218     -136.40218    
Loop time of 105.267 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.241 hours/ns, 9.500 timesteps/s
99.9% 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.73     | 104.73     | 104.73     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098087   | 0.098087   | 0.098087   |   0.0 |  0.09
Output  | 0.00021544 | 0.00021544 | 0.00021544 |   0.0 |  0.00
Modify  | 0.37672    | 0.37672    | 0.37672    |   0.0 |  0.36
Other   |            | 0.06056    |            |       |  0.06

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

Total # of neighbors = 127936
Ave neighs/atom = 63.968
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.772344476597, Press = 0.273624357710314
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    185000  -8023.6262     -8023.6262     -8108.8825     -8108.8825      329.95089      329.95089      24111.386      24111.386     -136.40218     -136.40218    
    186000  -8019.962      -8019.962      -8108.7957     -8108.7957      343.79552      343.79552      24128.278      24128.278     -1272.9741     -1272.9741    
Loop time of 105.608 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.07     | 105.07     | 105.07     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098006   | 0.098006   | 0.098006   |   0.0 |  0.09
Output  | 0.00017102 | 0.00017102 | 0.00017102 |   0.0 |  0.00
Modify  | 0.37711    | 0.37711    | 0.37711    |   0.0 |  0.36
Other   |            | 0.06074    |            |       |  0.06

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

Total # of neighbors = 127934
Ave neighs/atom = 63.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.766656039766, Press = 0.372255634293118
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    186000  -8019.962      -8019.962      -8108.7957     -8108.7957      343.79552      343.79552      24128.278      24128.278     -1272.9741     -1272.9741    
    187000  -8023.7007     -8023.7007     -8106.4067     -8106.4067      320.08105      320.08105      24144.071      24144.071     -2467.4184     -2467.4184    
Loop time of 106.635 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.09     | 106.09     | 106.09     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09857    | 0.09857    | 0.09857    |   0.0 |  0.09
Output  | 0.00016562 | 0.00016562 | 0.00016562 |   0.0 |  0.00
Modify  | 0.38158    | 0.38158    | 0.38158    |   0.0 |  0.36
Other   |            | 0.06081    |            |       |  0.06

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

Total # of neighbors = 127912
Ave neighs/atom = 63.956
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.773559997661, Press = 0.397587073061964
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    187000  -8023.7007     -8023.7007     -8106.4067     -8106.4067      320.08105      320.08105      24144.071      24144.071     -2467.4184     -2467.4184    
    188000  -8018.5012     -8018.5012     -8107.4918     -8107.4918      344.40308      344.40308      24156.197      24156.197     -3248.9316     -3248.9316    
Loop time of 106.352 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.81     | 105.81     | 105.81     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099106   | 0.099106   | 0.099106   |   0.0 |  0.09
Output  | 0.00020536 | 0.00020536 | 0.00020536 |   0.0 |  0.00
Modify  | 0.37947    | 0.37947    | 0.37947    |   0.0 |  0.36
Other   |            | 0.06045    |            |       |  0.06

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

Total # of neighbors = 127944
Ave neighs/atom = 63.972
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.773258441116, Press = 0.302432023320013
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    188000  -8018.5012     -8018.5012     -8107.4918     -8107.4918      344.40308      344.40308      24156.197      24156.197     -3248.9316     -3248.9316    
    189000  -8022.1989     -8022.1989     -8108.9148     -8108.9148      335.59959      335.59959      24144.996      24144.996     -2769.1656     -2769.1656    
Loop time of 106.498 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.583 hours/ns, 9.390 timesteps/s
99.9% 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.96     | 105.96     | 105.96     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097842   | 0.097842   | 0.097842   |   0.0 |  0.09
Output  | 0.0001641  | 0.0001641  | 0.0001641  |   0.0 |  0.00
Modify  | 0.37749    | 0.37749    | 0.37749    |   0.0 |  0.35
Other   |            | 0.0605     |            |       |  0.06

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

Total # of neighbors = 127920
Ave neighs/atom = 63.96
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.779370534129, Press = 0.103134159074937
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    189000  -8022.1989     -8022.1989     -8108.9148     -8108.9148      335.59959      335.59959      24144.996      24144.996     -2769.1656     -2769.1656    
    190000  -8014.1094     -8014.1094     -8105.6311     -8105.6311      354.1984       354.1984       24144.17       24144.17      -2042.1393     -2042.1393    
Loop time of 106.423 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.562 hours/ns, 9.396 timesteps/s
99.9% 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.88     | 105.88     | 105.88     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098288   | 0.098288   | 0.098288   |   0.0 |  0.09
Output  | 0.00020068 | 0.00020068 | 0.00020068 |   0.0 |  0.00
Modify  | 0.37919    | 0.37919    | 0.37919    |   0.0 |  0.36
Other   |            | 0.06106    |            |       |  0.06

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

Total # of neighbors = 127934
Ave neighs/atom = 63.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.79317347358, Press = 0.0451109190774693
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    190000  -8014.1094     -8014.1094     -8105.6311     -8105.6311      354.1984       354.1984       24144.17       24144.17      -2042.1393     -2042.1393    
    191000  -8023.7962     -8023.7962     -8108.7763     -8108.7763      328.88173      328.88173      24122.968      24122.968     -1142.3849     -1142.3849    
Loop time of 106.631 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.09     | 106.09     | 106.09     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098962   | 0.098962   | 0.098962   |   0.0 |  0.09
Output  | 0.00016572 | 0.00016572 | 0.00016572 |   0.0 |  0.00
Modify  | 0.38381    | 0.38381    | 0.38381    |   0.0 |  0.36
Other   |            | 0.06083    |            |       |  0.06

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

Total # of neighbors = 127956
Ave neighs/atom = 63.978
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.80639280069, Press = -0.0342511850068171
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    191000  -8023.7962     -8023.7962     -8108.7763     -8108.7763      328.88173      328.88173      24122.968      24122.968     -1142.3849     -1142.3849    
    192000  -8021.1382     -8021.1382     -8108.1951     -8108.1951      336.9193       336.9193       24127.1        24127.1       -1262.0426     -1262.0426    
Loop time of 107.926 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.801 ns/day, 29.980 hours/ns, 9.266 timesteps/s
99.9% 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.38     | 107.38     | 107.38     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099593   | 0.099593   | 0.099593   |   0.0 |  0.09
Output  | 0.00016509 | 0.00016509 | 0.00016509 |   0.0 |  0.00
Modify  | 0.38925    | 0.38925    | 0.38925    |   0.0 |  0.36
Other   |            | 0.06149    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127960 ave      127960 max      127960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127960
Ave neighs/atom = 63.98
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.807068554415, Press = -0.0623259248318551
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    192000  -8021.1382     -8021.1382     -8108.1951     -8108.1951      336.9193       336.9193       24127.1        24127.1       -1262.0426     -1262.0426    
    193000  -8020.176      -8020.176      -8108.2304     -8108.2304      340.7796       340.7796       24142.803      24142.803     -2369.215      -2369.215     
Loop time of 105.675 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.14     | 105.14     | 105.14     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098326   | 0.098326   | 0.098326   |   0.0 |  0.09
Output  | 0.00023389 | 0.00023389 | 0.00023389 |   0.0 |  0.00
Modify  | 0.37703    | 0.37703    | 0.37703    |   0.0 |  0.36
Other   |            | 0.06089    |            |       |  0.06

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

Total # of neighbors = 127938
Ave neighs/atom = 63.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.816290265221, Press = -0.328136260872984
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    193000  -8020.176      -8020.176      -8108.2304     -8108.2304      340.7796       340.7796       24142.803      24142.803     -2369.215      -2369.215     
    194000  -8023.2472     -8023.2472     -8107.3891     -8107.3891      325.63787      325.63787      24122.62       24122.62      -927.2678      -927.2678     
Loop time of 107.899 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.801 ns/day, 29.972 hours/ns, 9.268 timesteps/s
99.9% 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.35     | 107.35     | 107.35     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098784   | 0.098784   | 0.098784   |   0.0 |  0.09
Output  | 0.00024956 | 0.00024956 | 0.00024956 |   0.0 |  0.00
Modify  | 0.38796    | 0.38796    | 0.38796    |   0.0 |  0.36
Other   |            | 0.06131    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.835354718343, Press = -0.418047966203959
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    194000  -8023.2472     -8023.2472     -8107.3891     -8107.3891      325.63787      325.63787      24122.62       24122.62      -927.2678      -927.2678     
    195000  -8020.3145     -8020.3145     -8108.017      -8108.017       339.41797      339.41797      24123.043      24123.043     -772.20494     -772.20494    
Loop time of 106.169 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.491 hours/ns, 9.419 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.63     | 105.63     | 105.63     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097924   | 0.097924   | 0.097924   |   0.0 |  0.09
Output  | 0.00016549 | 0.00016549 | 0.00016549 |   0.0 |  0.00
Modify  | 0.37945    | 0.37945    | 0.37945    |   0.0 |  0.36
Other   |            | 0.06057    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127932 ave      127932 max      127932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127932
Ave neighs/atom = 63.966
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.842803569038, Press = -0.35293722584226
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    195000  -8020.3145     -8020.3145     -8108.017      -8108.017       339.41797      339.41797      24123.043      24123.043     -772.20494     -772.20494    
    196000  -8018.1789     -8018.1789     -8106.7124     -8106.7124      342.63404      342.63404      24117.714      24117.714     -197.5316      -197.5316     
Loop time of 108.144 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.799 ns/day, 30.040 hours/ns, 9.247 timesteps/s
99.9% 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.59     | 107.59     | 107.59     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10054    | 0.10054    | 0.10054    |   0.0 |  0.09
Output  | 0.00020452 | 0.00020452 | 0.00020452 |   0.0 |  0.00
Modify  | 0.3897     | 0.3897     | 0.3897     |   0.0 |  0.36
Other   |            | 0.06132    |            |       |  0.06

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

Total # of neighbors = 127948
Ave neighs/atom = 63.974
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.840744200588, Press = -0.198738271278667
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    196000  -8018.1789     -8018.1789     -8106.7124     -8106.7124      342.63404      342.63404      24117.714      24117.714     -197.5316      -197.5316     
    197000  -8022.7309     -8022.7309     -8108.4304     -8108.4304      331.66588      331.66588      24108.331      24108.331      207.29621      207.29621    
Loop time of 106.354 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.82     | 105.82     | 105.82     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097183   | 0.097183   | 0.097183   |   0.0 |  0.09
Output  | 0.00020255 | 0.00020255 | 0.00020255 |   0.0 |  0.00
Modify  | 0.37946    | 0.37946    | 0.37946    |   0.0 |  0.36
Other   |            | 0.05975    |            |       |  0.06

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

Total # of neighbors = 127948
Ave neighs/atom = 63.974
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.857650517146, Press = -0.0182318581564543
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    197000  -8022.7309     -8022.7309     -8108.4304     -8108.4304      331.66588      331.66588      24108.331      24108.331      207.29621      207.29621    
    198000  -8017.6421     -8017.6421     -8105.5931     -8105.5931      340.37919      340.37919      24115.82       24115.82       85.104831      85.104831    
Loop time of 105.285 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.75     | 104.75     | 104.75     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097844   | 0.097844   | 0.097844   |   0.0 |  0.09
Output  | 0.00016415 | 0.00016415 | 0.00016415 |   0.0 |  0.00
Modify  | 0.37571    | 0.37571    | 0.37571    |   0.0 |  0.36
Other   |            | 0.05999    |            |       |  0.06

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

Total # of neighbors = 127934
Ave neighs/atom = 63.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.865823843307, Press = 0.0633629606919403
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    198000  -8017.6421     -8017.6421     -8105.5931     -8105.5931      340.37919      340.37919      24115.82       24115.82       85.104831      85.104831    
    199000  -8022.2454     -8022.2454     -8107.0163     -8107.0163      328.07204      328.07204      24111.426      24111.426      50.522905      50.522905    
Loop time of 107.293 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.805 ns/day, 29.804 hours/ns, 9.320 timesteps/s
99.9% 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.75     | 106.75     | 106.75     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098999   | 0.098999   | 0.098999   |   0.0 |  0.09
Output  | 0.00016519 | 0.00016519 | 0.00016519 |   0.0 |  0.00
Modify  | 0.3847     | 0.3847     | 0.3847     |   0.0 |  0.36
Other   |            | 0.0617     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127914 ave      127914 max      127914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127914
Ave neighs/atom = 63.957
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.882814925961, Press = 0.098155291736654
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    199000  -8022.2454     -8022.2454     -8107.0163     -8107.0163      328.07204      328.07204      24111.426      24111.426      50.522905      50.522905    
    200000  -8019.4494     -8019.4494     -8107.9815     -8107.9815      342.62854      342.62854      24120.063      24120.063     -382.28978     -382.28978    
Loop time of 108.266 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.798 ns/day, 30.074 hours/ns, 9.237 timesteps/s
99.9% 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.71     | 107.71     | 107.71     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10002    | 0.10002    | 0.10002    |   0.0 |  0.09
Output  | 0.00016496 | 0.00016496 | 0.00016496 |   0.0 |  0.00
Modify  | 0.39013    | 0.39013    | 0.39013    |   0.0 |  0.36
Other   |            | 0.06182    |            |       |  0.06

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

Total # of neighbors = 127966
Ave neighs/atom = 63.983
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.88470770257, Press = 0.119579017274225
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    200000  -8019.4494     -8019.4494     -8107.9815     -8107.9815      342.62854      342.62854      24120.063      24120.063     -382.28978     -382.28978    
    201000  -8021.2527     -8021.2527     -8106.9686     -8106.9686      331.72963      331.72963      24122.549      24122.549     -624.09925     -624.09925    
Loop time of 106.998 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.807 ns/day, 29.722 hours/ns, 9.346 timesteps/s
99.9% 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.45     | 106.45     | 106.45     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099472   | 0.099472   | 0.099472   |   0.0 |  0.09
Output  | 0.00017618 | 0.00017618 | 0.00017618 |   0.0 |  0.00
Modify  | 0.38345    | 0.38345    | 0.38345    |   0.0 |  0.36
Other   |            | 0.06135    |            |       |  0.06

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

Total # of neighbors = 127928
Ave neighs/atom = 63.964
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.887542119646, Press = 0.17130959926183
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    201000  -8021.2527     -8021.2527     -8106.9686     -8106.9686      331.72963      331.72963      24122.549      24122.549     -624.09925     -624.09925    
    202000  -8019.1268     -8019.1268     -8103.9798     -8103.9798      328.39         328.39         24138.104      24138.104     -1481.32       -1481.32      
Loop time of 105.909 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.419 hours/ns, 9.442 timesteps/s
99.9% 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.37     | 105.37     | 105.37     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098211   | 0.098211   | 0.098211   |   0.0 |  0.09
Output  | 0.00016479 | 0.00016479 | 0.00016479 |   0.0 |  0.00
Modify  | 0.37689    | 0.37689    | 0.37689    |   0.0 |  0.36
Other   |            | 0.06088    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.90524741118, Press = 0.161156603555987
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    202000  -8019.1268     -8019.1268     -8103.9798     -8103.9798      328.39         328.39         24138.104      24138.104     -1481.32       -1481.32      
    203000  -8022.2162     -8022.2162     -8106.4523     -8106.4523      326.00237      326.00237      24156.133      24156.133     -3232.5047     -3232.5047    
Loop time of 107.228 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.806 ns/day, 29.786 hours/ns, 9.326 timesteps/s
99.9% 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.69     | 106.69     | 106.69     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099084   | 0.099084   | 0.099084   |   0.0 |  0.09
Output  | 0.00016707 | 0.00016707 | 0.00016707 |   0.0 |  0.00
Modify  | 0.38156    | 0.38156    | 0.38156    |   0.0 |  0.36
Other   |            | 0.06059    |            |       |  0.06

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

Total # of neighbors = 127926
Ave neighs/atom = 63.963
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.909563416332, Press = 0.122556357373827
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    203000  -8022.2162     -8022.2162     -8106.4523     -8106.4523      326.00237      326.00237      24156.133      24156.133     -3232.5047     -3232.5047    
    204000  -8020.9642     -8020.9642     -8105.8293     -8105.8293      328.4369       328.4369       24161.324      24161.324     -3474.7885     -3474.7885    
Loop time of 107.444 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.846 hours/ns, 9.307 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.9      | 106.9      | 106.9      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098994   | 0.098994   | 0.098994   |   0.0 |  0.09
Output  | 0.00047904 | 0.00047904 | 0.00047904 |   0.0 |  0.00
Modify  | 0.38435    | 0.38435    | 0.38435    |   0.0 |  0.36
Other   |            | 0.06133    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127906 ave      127906 max      127906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127906
Ave neighs/atom = 63.953
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.910251248899, Press = -0.0377288577743896
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    204000  -8020.9642     -8020.9642     -8105.8293     -8105.8293      328.4369       328.4369       24161.324      24161.324     -3474.7885     -3474.7885    
    205000  -8023.4587     -8023.4587     -8107.6986     -8107.6986      326.01733      326.01733      24128.552      24128.552     -1413.3895     -1413.3895    
Loop time of 108.511 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.796 ns/day, 30.142 hours/ns, 9.216 timesteps/s
99.9% 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.96     | 107.96     | 107.96     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10063    | 0.10063    | 0.10063    |   0.0 |  0.09
Output  | 0.00016546 | 0.00016546 | 0.00016546 |   0.0 |  0.00
Modify  | 0.39024    | 0.39024    | 0.39024    |   0.0 |  0.36
Other   |            | 0.06185    |            |       |  0.06

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

Total # of neighbors = 127920
Ave neighs/atom = 63.96
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.926207040171, Press = -0.0759759165644317
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    205000  -8023.4587     -8023.4587     -8107.6986     -8107.6986      326.01733      326.01733      24128.552      24128.552     -1413.3895     -1413.3895    
    206000  -8020.2468     -8020.2468     -8108.2216     -8108.2216      340.47156      340.47156      24121.837      24121.837     -794.90132     -794.90132    
Loop time of 107.459 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.850 hours/ns, 9.306 timesteps/s
99.9% 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.91     | 106.91     | 106.91     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099107   | 0.099107   | 0.099107   |   0.0 |  0.09
Output  | 0.00016389 | 0.00016389 | 0.00016389 |   0.0 |  0.00
Modify  | 0.38546    | 0.38546    | 0.38546    |   0.0 |  0.36
Other   |            | 0.06122    |            |       |  0.06

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

Total # of neighbors = 127902
Ave neighs/atom = 63.951
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.929236873702, Press = -0.0300611565634638
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    206000  -8020.2468     -8020.2468     -8108.2216     -8108.2216      340.47156      340.47156      24121.837      24121.837     -794.90132     -794.90132    
    207000  -8023.0854     -8023.0854     -8110.1745     -8110.1745      337.04379      337.04379      24120.39       24120.39      -925.70129     -925.70129    
Loop time of 107.376 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.805 ns/day, 29.827 hours/ns, 9.313 timesteps/s
99.9% 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.83     | 106.83     | 106.83     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098509   | 0.098509   | 0.098509   |   0.0 |  0.09
Output  | 0.00016498 | 0.00016498 | 0.00016498 |   0.0 |  0.00
Modify  | 0.38582    | 0.38582    | 0.38582    |   0.0 |  0.36
Other   |            | 0.06104    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4115 ave        4115 max        4115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127912 ave      127912 max      127912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127912
Ave neighs/atom = 63.956
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.925283083356, Press = -0.0380200040182331
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    207000  -8023.0854     -8023.0854     -8110.1745     -8110.1745      337.04379      337.04379      24120.39       24120.39      -925.70129     -925.70129    
    208000  -8024.1044     -8024.1044     -8109.2905     -8109.2905      329.67893      329.67893      24117.337      24117.337     -680.70186     -680.70186    
Loop time of 106.406 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.557 hours/ns, 9.398 timesteps/s
99.9% 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.87     | 105.87     | 105.87     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098598   | 0.098598   | 0.098598   |   0.0 |  0.09
Output  | 0.00016764 | 0.00016764 | 0.00016764 |   0.0 |  0.00
Modify  | 0.3812     | 0.3812     | 0.3812     |   0.0 |  0.36
Other   |            | 0.06027    |            |       |  0.06

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

Total # of neighbors = 127938
Ave neighs/atom = 63.969
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.914859105255, Press = -0.11479299956954
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    208000  -8024.1044     -8024.1044     -8109.2905     -8109.2905      329.67893      329.67893      24117.337      24117.337     -680.70186     -680.70186    
    209000  -8022.1938     -8022.1938     -8109.0175     -8109.0175      336.01637      336.01637      24115.353      24115.353     -268.83112     -268.83112    
Loop time of 107.355 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.805 ns/day, 29.821 hours/ns, 9.315 timesteps/s
99.9% 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.81     | 106.81     | 106.81     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099406   | 0.099406   | 0.099406   |   0.0 |  0.09
Output  | 0.00016817 | 0.00016817 | 0.00016817 |   0.0 |  0.00
Modify  | 0.38788    | 0.38788    | 0.38788    |   0.0 |  0.36
Other   |            | 0.06138    |            |       |  0.06

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

Total # of neighbors = 127930
Ave neighs/atom = 63.965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.918384034883, Press = -0.253873155973578
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    209000  -8022.1938     -8022.1938     -8109.0175     -8109.0175      336.01637      336.01637      24115.353      24115.353     -268.83112     -268.83112    
    210000  -8023.5175     -8023.5175     -8109.7322     -8109.7322      333.65985      333.65985      24106.974      24106.974      231.0831       231.0831     
Loop time of 108.079 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.799 ns/day, 30.022 hours/ns, 9.252 timesteps/s
99.9% 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.53     | 107.53     | 107.53     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099775   | 0.099775   | 0.099775   |   0.0 |  0.09
Output  | 0.0001663  | 0.0001663  | 0.0001663  |   0.0 |  0.00
Modify  | 0.38945    | 0.38945    | 0.38945    |   0.0 |  0.36
Other   |            | 0.06139    |            |       |  0.06

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

Total # of neighbors = 127950
Ave neighs/atom = 63.975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.906079012107, Press = -0.199137212542311
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    210000  -8023.5175     -8023.5175     -8109.7322     -8109.7322      333.65985      333.65985      24106.974      24106.974      231.0831       231.0831     
    211000  -8019.3833     -8019.3833     -8106.6615     -8106.6615      337.77577      337.77577      24099.769      24099.769      1091.758       1091.758     
Loop time of 106.512 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.811 ns/day, 29.587 hours/ns, 9.389 timesteps/s
99.9% 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.97     | 105.97     | 105.97     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098825   | 0.098825   | 0.098825   |   0.0 |  0.09
Output  | 0.00020689 | 0.00020689 | 0.00020689 |   0.0 |  0.00
Modify  | 0.38241    | 0.38241    | 0.38241    |   0.0 |  0.36
Other   |            | 0.06092    |            |       |  0.06

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

Total # of neighbors = 127952
Ave neighs/atom = 63.976
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.898048004346, Press = -0.291568704537125
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    211000  -8019.3833     -8019.3833     -8106.6615     -8106.6615      337.77577      337.77577      24099.769      24099.769      1091.758       1091.758     
    212000  -8027.5778     -8027.5778     -8109.8221     -8109.8221      318.2936       318.2936       24070.373      24070.373      2778.9607      2778.9607    
Loop time of 107.692 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.802 ns/day, 29.914 hours/ns, 9.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    | 107.14     | 107.14     | 107.14     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099702   | 0.099702   | 0.099702   |   0.0 |  0.09
Output  | 0.00016575 | 0.00016575 | 0.00016575 |   0.0 |  0.00
Modify  | 0.38526    | 0.38526    | 0.38526    |   0.0 |  0.36
Other   |            | 0.06149    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.892689555161, Press = -0.312371855464984
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    212000  -8027.5778     -8027.5778     -8109.8221     -8109.8221      318.2936       318.2936       24070.373      24070.373      2778.9607      2778.9607    
    213000  -8019.3072     -8019.3072     -8106.8775     -8106.8775      338.90612      338.90612      24073.925      24073.925      3244.4164      3244.4164    
Loop time of 107.702 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.802 ns/day, 29.917 hours/ns, 9.285 timesteps/s
99.9% 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.15     | 107.15     | 107.15     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098706   | 0.098706   | 0.098706   |   0.0 |  0.09
Output  | 0.00020148 | 0.00020148 | 0.00020148 |   0.0 |  0.00
Modify  | 0.38788    | 0.38788    | 0.38788    |   0.0 |  0.36
Other   |            | 0.06134    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4118 ave        4118 max        4118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127944 ave      127944 max      127944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127944
Ave neighs/atom = 63.972
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.884056931372, Press = -0.19810006812864
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    213000  -8019.3072     -8019.3072     -8106.8775     -8106.8775      338.90612      338.90612      24073.925      24073.925      3244.4164      3244.4164    
    214000  -8020.7818     -8020.7818     -8107.5489     -8107.5489      335.79766      335.79766      24091.229      24091.229      1663.4575      1663.4575    
Loop time of 106.604 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.06     | 106.06     | 106.06     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098557   | 0.098557   | 0.098557   |   0.0 |  0.09
Output  | 0.00021859 | 0.00021859 | 0.00021859 |   0.0 |  0.00
Modify  | 0.38353    | 0.38353    | 0.38353    |   0.0 |  0.36
Other   |            | 0.06149    |            |       |  0.06

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

Total # of neighbors = 127948
Ave neighs/atom = 63.974
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.883136290044, Press = -0.0422610262291756
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    214000  -8020.7818     -8020.7818     -8107.5489     -8107.5489      335.79766      335.79766      24091.229      24091.229      1663.4575      1663.4575    
    215000  -8021.8212     -8021.8212     -8109.3446     -8109.3446      338.72493      338.72493      24095.304      24095.304      1184.3048      1184.3048    
Loop time of 108.4 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.797 ns/day, 30.111 hours/ns, 9.225 timesteps/s
99.9% 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.85     | 107.85     | 107.85     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09983    | 0.09983    | 0.09983    |   0.0 |  0.09
Output  | 0.00016441 | 0.00016441 | 0.00016441 |   0.0 |  0.00
Modify  | 0.38932    | 0.38932    | 0.38932    |   0.0 |  0.36
Other   |            | 0.06141    |            |       |  0.06

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

Total # of neighbors = 127972
Ave neighs/atom = 63.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.899016738473, Press = 0.00458089948625461
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    215000  -8021.8212     -8021.8212     -8109.3446     -8109.3446      338.72493      338.72493      24095.304      24095.304      1184.3048      1184.3048    
    216000  -8018.9677     -8018.9677     -8104.3342     -8104.3342      330.37712      330.37712      24097.101      24097.101      1588.1219      1588.1219    
Loop time of 105.789 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.386 hours/ns, 9.453 timesteps/s
99.9% 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.25     | 105.25     | 105.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098255   | 0.098255   | 0.098255   |   0.0 |  0.09
Output  | 0.00016501 | 0.00016501 | 0.00016501 |   0.0 |  0.00
Modify  | 0.37744    | 0.37744    | 0.37744    |   0.0 |  0.36
Other   |            | 0.06056    |            |       |  0.06

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

Total # of neighbors = 127944
Ave neighs/atom = 63.972
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.90697628186, Press = 0.0481193003709896
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    216000  -8018.9677     -8018.9677     -8104.3342     -8104.3342      330.37712      330.37712      24097.101      24097.101      1588.1219      1588.1219    
    217000  -8023.2395     -8023.2395     -8108.0517     -8108.0517      328.23224      328.23224      24087.695      24087.695      1881.5648      1881.5648    
Loop time of 107.21 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.806 ns/day, 29.781 hours/ns, 9.327 timesteps/s
99.9% 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.67     | 106.67     | 106.67     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098838   | 0.098838   | 0.098838   |   0.0 |  0.09
Output  | 0.00016352 | 0.00016352 | 0.00016352 |   0.0 |  0.00
Modify  | 0.38269    | 0.38269    | 0.38269    |   0.0 |  0.36
Other   |            | 0.06026    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.923955572032, Press = 0.272721429483207
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    217000  -8023.2395     -8023.2395     -8108.0517     -8108.0517      328.23224      328.23224      24087.695      24087.695      1881.5648      1881.5648    
    218000  -8022.542      -8022.542      -8107.4537     -8107.4537      328.61701      328.61701      24091.79       24091.79       1498.7181      1498.7181    
Loop time of 107.208 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.806 ns/day, 29.780 hours/ns, 9.328 timesteps/s
99.9% 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.67     | 106.67     | 106.67     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099249   | 0.099249   | 0.099249   |   0.0 |  0.09
Output  | 0.00019968 | 0.00019968 | 0.00019968 |   0.0 |  0.00
Modify  | 0.38197    | 0.38197    | 0.38197    |   0.0 |  0.36
Other   |            | 0.06083    |            |       |  0.06

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

Total # of neighbors = 127950
Ave neighs/atom = 63.975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.924988729799, Press = 0.600654675653561
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    218000  -8022.542      -8022.542      -8107.4537     -8107.4537      328.61701      328.61701      24091.79       24091.79       1498.7181      1498.7181    
    219000  -8022.1932     -8022.1932     -8106.711      -8106.711       327.09266      327.09266      24110.532      24110.532      223.53208      223.53208    
Loop time of 108.218 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.798 ns/day, 30.060 hours/ns, 9.241 timesteps/s
99.9% 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.67     | 107.67     | 107.67     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099904   | 0.099904   | 0.099904   |   0.0 |  0.09
Output  | 0.00016538 | 0.00016538 | 0.00016538 |   0.0 |  0.00
Modify  | 0.38881    | 0.38881    | 0.38881    |   0.0 |  0.36
Other   |            | 0.06104    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127914 ave      127914 max      127914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127914
Ave neighs/atom = 63.957
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.927342724578, Press = 0.42724645844176
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    219000  -8022.1932     -8022.1932     -8106.711      -8106.711       327.09266      327.09266      24110.532      24110.532      223.53208      223.53208    
    220000  -8023.4496     -8023.4496     -8108.1663     -8108.1663      327.86244      327.86244      24119.804      24119.804     -675.22608     -675.22608    
Loop time of 104.83 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.119 hours/ns, 9.539 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.3      | 104.3      | 104.3      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0967     | 0.0967     | 0.0967     |   0.0 |  0.09
Output  | 0.00016548 | 0.00016548 | 0.00016548 |   0.0 |  0.00
Modify  | 0.37265    | 0.37265    | 0.37265    |   0.0 |  0.36
Other   |            | 0.06008    |            |       |  0.06

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

Total # of neighbors = 127942
Ave neighs/atom = 63.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.915689624409, Press = 0.33778645699175
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    220000  -8023.4496     -8023.4496     -8108.1663     -8108.1663      327.86244      327.86244      24119.804      24119.804     -675.22608     -675.22608    
    221000  -8021.188      -8021.188      -8109.6152     -8109.6152      342.22263      342.22263      24129.572      24129.572     -1549.6501     -1549.6501    
Loop time of 108.688 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.795 ns/day, 30.191 hours/ns, 9.201 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.14     | 108.14     | 108.14     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099538   | 0.099538   | 0.099538   |   0.0 |  0.09
Output  | 0.00016344 | 0.00016344 | 0.00016344 |   0.0 |  0.00
Modify  | 0.38728    | 0.38728    | 0.38728    |   0.0 |  0.36
Other   |            | 0.06131    |            |       |  0.06

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

Total # of neighbors = 127942
Ave neighs/atom = 63.971
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.919427497617, Press = 0.168947859048242
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    221000  -8021.188      -8021.188      -8109.6152     -8109.6152      342.22263      342.22263      24129.572      24129.572     -1549.6501     -1549.6501    
    222000  -8016.8179     -8016.8179     -8105.335      -8105.335       342.57021      342.57021      24138.581      24138.581     -1540.6863     -1540.6863    
Loop time of 108.438 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.797 ns/day, 30.122 hours/ns, 9.222 timesteps/s
99.9% 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.88     | 107.88     | 107.88     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10052    | 0.10052    | 0.10052    |   0.0 |  0.09
Output  | 0.00016548 | 0.00016548 | 0.00016548 |   0.0 |  0.00
Modify  | 0.39127    | 0.39127    | 0.39127    |   0.0 |  0.36
Other   |            | 0.06167    |            |       |  0.06

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

Total # of neighbors = 127946
Ave neighs/atom = 63.973
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.92509603277, Press = 0.173392310899423
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    222000  -8016.8179     -8016.8179     -8105.335      -8105.335       342.57021      342.57021      24138.581      24138.581     -1540.6863     -1540.6863    
    223000  -8023.8222     -8023.8222     -8108.6709     -8108.6709      328.37349      328.37349      24148.624      24148.624     -2908.1095     -2908.1095    
Loop time of 106.66 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.628 hours/ns, 9.376 timesteps/s
99.9% 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.12     | 106.12     | 106.12     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099218   | 0.099218   | 0.099218   |   0.0 |  0.09
Output  | 0.00020315 | 0.00020315 | 0.00020315 |   0.0 |  0.00
Modify  | 0.38038    | 0.38038    | 0.38038    |   0.0 |  0.36
Other   |            | 0.0613     |            |       |  0.06

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

Total # of neighbors = 127918
Ave neighs/atom = 63.959
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.93650365265, Press = 0.159180613702308
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    223000  -8023.8222     -8023.8222     -8108.6709     -8108.6709      328.37349      328.37349      24148.624      24148.624     -2908.1095     -2908.1095    
    224000  -8019.3093     -8019.3093     -8104.6039     -8104.6039      330.09879      330.09879      24210.967      24210.967     -7201.899      -7201.899     
Loop time of 105.785 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.385 hours/ns, 9.453 timesteps/s
99.9% 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.25     | 105.25     | 105.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098141   | 0.098141   | 0.098141   |   0.0 |  0.09
Output  | 0.00019407 | 0.00019407 | 0.00019407 |   0.0 |  0.00
Modify  | 0.37807    | 0.37807    | 0.37807    |   0.0 |  0.36
Other   |            | 0.06071    |            |       |  0.06

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

Total # of neighbors = 127920
Ave neighs/atom = 63.96
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.945435637617, Press = 0.086444555745586
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    224000  -8019.3093     -8019.3093     -8104.6039     -8104.6039      330.09879      330.09879      24210.967      24210.967     -7201.899      -7201.899     
    225000  -8019.2208     -8019.2208     -8107.0764     -8107.0764      340.01021      340.01021      24154.184      24154.184     -2969.1028     -2969.1028    
Loop time of 107.757 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.802 ns/day, 29.933 hours/ns, 9.280 timesteps/s
99.9% 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.21     | 107.21     | 107.21     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099396   | 0.099396   | 0.099396   |   0.0 |  0.09
Output  | 0.00024944 | 0.00024944 | 0.00024944 |   0.0 |  0.00
Modify  | 0.38807    | 0.38807    | 0.38807    |   0.0 |  0.36
Other   |            | 0.06108    |            |       |  0.06

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

Total # of neighbors = 127914
Ave neighs/atom = 63.957
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.949483378546, Press = -0.0441988652577464
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    225000  -8019.2208     -8019.2208     -8107.0764     -8107.0764      340.01021      340.01021      24154.184      24154.184     -2969.1028     -2969.1028    
    226000  -8023.6015     -8023.6015     -8109.3022     -8109.3022      331.6705       331.6705       24134.198      24134.198     -1933.4449     -1933.4449    
Loop time of 106.375 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.84     | 105.84     | 105.84     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098249   | 0.098249   | 0.098249   |   0.0 |  0.09
Output  | 0.00016381 | 0.00016381 | 0.00016381 |   0.0 |  0.00
Modify  | 0.37781    | 0.37781    | 0.37781    |   0.0 |  0.36
Other   |            | 0.06074    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 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 = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.943143853944, Press = -0.0767938586917928
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    226000  -8023.6015     -8023.6015     -8109.3022     -8109.3022      331.6705       331.6705       24134.198      24134.198     -1933.4449     -1933.4449    
    227000  -8021.6421     -8021.6421     -8107.2336     -8107.2336      331.24797      331.24797      24129.77       24129.77      -1145.3085     -1145.3085    
Loop time of 106.706 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.641 hours/ns, 9.372 timesteps/s
99.9% 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.17     | 106.17     | 106.17     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098673   | 0.098673   | 0.098673   |   0.0 |  0.09
Output  | 0.0001678  | 0.0001678  | 0.0001678  |   0.0 |  0.00
Modify  | 0.38063    | 0.38063    | 0.38063    |   0.0 |  0.36
Other   |            | 0.06087    |            |       |  0.06

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

Total # of neighbors = 127936
Ave neighs/atom = 63.968
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.937255652961, Press = -0.0844854438035362
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    227000  -8021.6421     -8021.6421     -8107.2336     -8107.2336      331.24797      331.24797      24129.77       24129.77      -1145.3085     -1145.3085    
    228000  -8019.6371     -8019.6371     -8107.241      -8107.241       339.03608      339.03608      24134.48       24134.48      -1574.6003     -1574.6003    
Loop time of 105.787 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.385 hours/ns, 9.453 timesteps/s
99.9% 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.25     | 105.25     | 105.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098412   | 0.098412   | 0.098412   |   0.0 |  0.09
Output  | 0.0001632  | 0.0001632  | 0.0001632  |   0.0 |  0.00
Modify  | 0.37649    | 0.37649    | 0.37649    |   0.0 |  0.36
Other   |            | 0.0605     |            |       |  0.06

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

Total # of neighbors = 127934
Ave neighs/atom = 63.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.934761410219, Press = -0.191080265461615
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    228000  -8019.6371     -8019.6371     -8107.241      -8107.241       339.03608      339.03608      24134.48       24134.48      -1574.6003     -1574.6003    
    229000  -8022.7629     -8022.7629     -8107.5989     -8107.5989      328.32399      328.32399      24134.867      24134.867     -1684.5009     -1684.5009    
Loop time of 106.133 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.481 hours/ns, 9.422 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.59     | 105.59     | 105.59     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098491   | 0.098491   | 0.098491   |   0.0 |  0.09
Output  | 0.0001654  | 0.0001654  | 0.0001654  |   0.0 |  0.00
Modify  | 0.3798     | 0.3798     | 0.3798     |   0.0 |  0.36
Other   |            | 0.06063    |            |       |  0.06

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

Total # of neighbors = 127904
Ave neighs/atom = 63.952
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.945505882105, Press = -0.426134799264289
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    229000  -8022.7629     -8022.7629     -8107.5989     -8107.5989      328.32399      328.32399      24134.867      24134.867     -1684.5009     -1684.5009    
    230000  -8016.0479     -8016.0479     -8104.5711     -8104.5711      342.59411      342.59411      24130.082      24130.082     -664.49533     -664.49533    
Loop time of 106.83 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.809 ns/day, 29.675 hours/ns, 9.361 timesteps/s
99.9% 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.29     | 106.29     | 106.29     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098689   | 0.098689   | 0.098689   |   0.0 |  0.09
Output  | 0.00022966 | 0.00022966 | 0.00022966 |   0.0 |  0.00
Modify  | 0.38207    | 0.38207    | 0.38207    |   0.0 |  0.36
Other   |            | 0.06035    |            |       |  0.06

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

Total # of neighbors = 127934
Ave neighs/atom = 63.967
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.954784706266, Press = -0.441735993372494
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   
    230000  -8016.0479     -8016.0479     -8104.5711     -8104.5711      342.59411      342.59411      24130.082      24130.082     -664.49533     -664.49533    
    231000  -8023.5805     -8023.5805     -8108.2649     -8108.2649      327.73763      327.73763      24106.841      24106.841      484.0545       484.0545     
Loop time of 107.655 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.803 ns/day, 29.904 hours/ns, 9.289 timesteps/s
99.9% 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.11     | 107.11     | 107.11     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098481   | 0.098481   | 0.098481   |   0.0 |  0.09
Output  | 0.00019652 | 0.00019652 | 0.00019652 |   0.0 |  0.00
Modify  | 0.38681    | 0.38681    | 0.38681    |   0.0 |  0.36
Other   |            | 0.06128    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4117 ave        4117 max        4117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       127884 ave      127884 max      127884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127884
Ave neighs/atom = 63.942
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
jump SELF break

# Write final averaged volume to file if temperature and volume have converged; otherwise wirte a
# flag to indicate non-convergence.
variable      myStep equal step
if "${myStep} < 2000000" then "print '${V}'  file output/vol_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
24112.2967302494

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0