# 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.003 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_LeeBaskesKim_2001_Cr__MO_134550636109_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 293.15*${_u_temperature}
variable temp_converted equal 293.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_134550636109_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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8124.2527     -8124.2527     -8200          -8200           293.15         293.15         23912.212      23912.212      3383.4945      3383.4945    
      1000  -8042.8274     -8042.8274     -8121.8998     -8121.8998      306.01823      306.01823      24118.32       24118.32      -2371.9585     -2371.9585    
Loop time of 94.9759 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.910 ns/day, 26.382 hours/ns, 10.529 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.495     | 94.495     | 94.495     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075234   | 0.075234   | 0.075234   |   0.0 |  0.08
Output  | 0.00021856 | 0.00021856 | 0.00021856 |   0.0 |  0.00
Modify  | 0.34992    | 0.34992    | 0.34992    |   0.0 |  0.37
Other   |            | 0.05588    |            |       |  0.06

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

Total # of neighbors = 116000
Ave neighs/atom = 58
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -8042.8274     -8042.8274     -8121.8998     -8121.8998      306.01823      306.01823      24118.32       24118.32      -2371.9585     -2371.9585    
      2000  -8044.0226     -8044.0226     -8118.8408     -8118.8408      289.55417      289.55417      24067.574      24067.574      1235.9301      1235.9301    
Loop time of 96.0103 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.670 hours/ns, 10.416 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.546     | 95.546     | 95.546     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07252    | 0.07252    | 0.07252    |   0.0 |  0.08
Output  | 0.00020406 | 0.00020406 | 0.00020406 |   0.0 |  0.00
Modify  | 0.33545    | 0.33545    | 0.33545    |   0.0 |  0.35
Other   |            | 0.05582    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2949 ave        2949 max        2949 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116140 ave      116140 max      116140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116140
Ave neighs/atom = 58.07
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -8044.0226     -8044.0226     -8118.8408     -8118.8408      289.55417      289.55417      24067.574      24067.574      1235.9301      1235.9301    
      3000  -8044.719      -8044.719      -8117.0888     -8117.0888      280.0785       280.0785       24105.587      24105.587     -1423.323      -1423.323     
Loop time of 112.856 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.349 hours/ns, 8.861 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.29     | 112.29     | 112.29     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08296    | 0.08296    | 0.08296    |   0.0 |  0.07
Output  | 0.00030073 | 0.00030073 | 0.00030073 |   0.0 |  0.00
Modify  | 0.42155    | 0.42155    | 0.42155    |   0.0 |  0.37
Other   |            | 0.06145    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2947 ave        2947 max        2947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116224 ave      116224 max      116224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116224
Ave neighs/atom = 58.112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -8044.719      -8044.719      -8117.0888     -8117.0888      280.0785       280.0785       24105.587      24105.587     -1423.323      -1423.323     
      4000  -8043.0294     -8043.0294     -8119.6408     -8119.6408      296.49418      296.49418      24061.937      24061.937      1908.989       1908.989     
Loop time of 113.015 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.393 hours/ns, 8.848 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.46     | 112.46     | 112.46     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082378   | 0.082378   | 0.082378   |   0.0 |  0.07
Output  | 0.00026185 | 0.00026185 | 0.00026185 |   0.0 |  0.00
Modify  | 0.41404    | 0.41404    | 0.41404    |   0.0 |  0.37
Other   |            | 0.06119    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116206 ave      116206 max      116206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116206
Ave neighs/atom = 58.103
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -8043.0294     -8043.0294     -8119.6408     -8119.6408      296.49418      296.49418      24061.937      24061.937      1908.989       1908.989     
      5000  -8045.0277     -8045.0277     -8124.0092     -8124.0092      305.66673      305.66673      24124.13       24124.13      -3315.411      -3315.411     
Loop time of 112.797 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.333 hours/ns, 8.865 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.23     | 112.23     | 112.23     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082369   | 0.082369   | 0.082369   |   0.0 |  0.07
Output  | 0.00023783 | 0.00023783 | 0.00023783 |   0.0 |  0.00
Modify  | 0.42014    | 0.42014    | 0.42014    |   0.0 |  0.37
Other   |            | 0.06148    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116236 ave      116236 max      116236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116236
Ave neighs/atom = 58.118
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.79580567948, Press = 2148.15240845576
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -8045.0277     -8045.0277     -8124.0092     -8124.0092      305.66673      305.66673      24124.13       24124.13      -3315.411      -3315.411     
      6000  -8042.8602     -8042.8602     -8117.9177     -8117.9177      290.48032      290.48032      24076.795      24076.795      880.38139      880.38139    
Loop time of 112.624 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.03     | 112.03     | 112.03     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083625   | 0.083625   | 0.083625   |   0.0 |  0.07
Output  | 0.00020534 | 0.00020534 | 0.00020534 |   0.0 |  0.00
Modify  | 0.44725    | 0.44725    | 0.44725    |   0.0 |  0.40
Other   |            | 0.06142    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116162 ave      116162 max      116162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116162
Ave neighs/atom = 58.081
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.643367355729, Press = 60.4061924791895
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -8042.8602     -8042.8602     -8117.9177     -8117.9177      290.48032      290.48032      24076.795      24076.795      880.38139      880.38139    
      7000  -8045.7127     -8045.7127     -8120.8099     -8120.8099      290.63357      290.63357      24074.134      24074.134      680.22539      680.22539    
Loop time of 103.249 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.837 ns/day, 28.680 hours/ns, 9.685 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.72     | 102.72     | 102.72     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076542   | 0.076542   | 0.076542   |   0.0 |  0.07
Output  | 0.00017115 | 0.00017115 | 0.00017115 |   0.0 |  0.00
Modify  | 0.39217    | 0.39217    | 0.39217    |   0.0 |  0.38
Other   |            | 0.05741    |            |       |  0.06

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

Total # of neighbors = 116226
Ave neighs/atom = 58.113
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.256416146101, Press = 81.1098726647249
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -8045.7127     -8045.7127     -8120.8099     -8120.8099      290.63357      290.63357      24074.134      24074.134      680.22539      680.22539    
      8000  -8040.8687     -8040.8687     -8119.3257     -8119.3257      303.63673      303.63673      24106.641      24106.641     -1549.9398     -1549.9398    
Loop time of 96.6141 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.837 hours/ns, 10.350 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.13      | 96.13      | 96.13      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072491   | 0.072491   | 0.072491   |   0.0 |  0.08
Output  | 0.00016965 | 0.00016965 | 0.00016965 |   0.0 |  0.00
Modify  | 0.35733    | 0.35733    | 0.35733    |   0.0 |  0.37
Other   |            | 0.05419    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116202 ave      116202 max      116202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116202
Ave neighs/atom = 58.101
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.664425660947, Press = 27.0437651106569
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -8040.8687     -8040.8687     -8119.3257     -8119.3257      303.63673      303.63673      24106.641      24106.641     -1549.9398     -1549.9398    
      9000  -8044.286      -8044.286      -8118.8165     -8118.8165      288.44084      288.44084      24065.142      24065.142      1605.3712      1605.3712    
Loop time of 96.6066 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.835 hours/ns, 10.351 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.122     | 96.122     | 96.122     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072878   | 0.072878   | 0.072878   |   0.0 |  0.08
Output  | 0.00017285 | 0.00017285 | 0.00017285 |   0.0 |  0.00
Modify  | 0.35775    | 0.35775    | 0.35775    |   0.0 |  0.37
Other   |            | 0.05397    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116208 ave      116208 max      116208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116208
Ave neighs/atom = 58.104
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.919247389973, Press = 35.9643911861446
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -8044.286      -8044.286      -8118.8165     -8118.8165      288.44084      288.44084      24065.142      24065.142      1605.3712      1605.3712    
     10000  -8042.539      -8042.539      -8118.4382     -8118.4382      293.73766      293.73766      24130.952      24130.952     -3284.3225     -3284.3225    
Loop time of 96.7726 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.881 hours/ns, 10.334 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.289     | 96.289     | 96.289     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073212   | 0.073212   | 0.073212   |   0.0 |  0.08
Output  | 0.00017148 | 0.00017148 | 0.00017148 |   0.0 |  0.00
Modify  | 0.35668    | 0.35668    | 0.35668    |   0.0 |  0.37
Other   |            | 0.05391    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116198 ave      116198 max      116198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116198
Ave neighs/atom = 58.099
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 294.329222328581, Press = 14.0674497357613
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -8042.539      -8042.539      -8118.4382     -8118.4382      293.73766      293.73766      24130.952      24130.952     -3284.3225     -3284.3225    
     11000  -8042.3212     -8042.3212     -8118.3845     -8118.3845      294.37267      294.37267      24036.03       24036.03       4018.7751      4018.7751    
Loop time of 96.633 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.843 hours/ns, 10.348 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.149     | 96.149     | 96.149     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072785   | 0.072785   | 0.072785   |   0.0 |  0.08
Output  | 0.00020848 | 0.00020848 | 0.00020848 |   0.0 |  0.00
Modify  | 0.3576     | 0.3576     | 0.3576     |   0.0 |  0.37
Other   |            | 0.05379    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116174 ave      116174 max      116174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116174
Ave neighs/atom = 58.087
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 294.256103265516, Press = 25.5431208562912
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -8042.3212     -8042.3212     -8118.3845     -8118.3845      294.37267      294.37267      24036.03       24036.03       4018.7751      4018.7751    
     12000  -8047.6124     -8047.6124     -8121.2649     -8121.2649      285.04282      285.04282      24118.739      24118.739     -2806.6956     -2806.6956    
Loop time of 96.7531 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.876 hours/ns, 10.336 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.268     | 96.268     | 96.268     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073166   | 0.073166   | 0.073166   |   0.0 |  0.08
Output  | 0.00016984 | 0.00016984 | 0.00016984 |   0.0 |  0.00
Modify  | 0.35805    | 0.35805    | 0.35805    |   0.0 |  0.37
Other   |            | 0.05397    |            |       |  0.06

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

Total # of neighbors = 116250
Ave neighs/atom = 58.125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.888730584974, Press = 17.1997758537196
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8047.6124     -8047.6124     -8121.2649     -8121.2649      285.04282      285.04282      24118.739      24118.739     -2806.6956     -2806.6956    
     13000  -8042.8912     -8042.8912     -8118.2416     -8118.2416      291.6138       291.6138       24053.593      24053.593      2662.7221      2662.7221    
Loop time of 96.622 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.839 hours/ns, 10.350 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.138     | 96.138     | 96.138     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072468   | 0.072468   | 0.072468   |   0.0 |  0.08
Output  | 0.0001707  | 0.0001707  | 0.0001707  |   0.0 |  0.00
Modify  | 0.35723    | 0.35723    | 0.35723    |   0.0 |  0.37
Other   |            | 0.05377    |            |       |  0.06

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

Total # of neighbors = 116156
Ave neighs/atom = 58.078
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.656605133599, Press = 15.0045705404742
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -8042.8912     -8042.8912     -8118.2416     -8118.2416      291.6138       291.6138       24053.593      24053.593      2662.7221      2662.7221    
     14000  -8046.6473     -8046.6473     -8120.4415     -8120.4415      285.59091      285.59091      24105.366      24105.366     -1683.6177     -1683.6177    
Loop time of 96.6512 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.848 hours/ns, 10.346 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.158     | 96.158     | 96.158     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080125   | 0.080125   | 0.080125   |   0.0 |  0.08
Output  | 0.00018019 | 0.00018019 | 0.00018019 |   0.0 |  0.00
Modify  | 0.35973    | 0.35973    | 0.35973    |   0.0 |  0.37
Other   |            | 0.05313    |            |       |  0.05

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

Total # of neighbors = 116218
Ave neighs/atom = 58.109
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.346129658986, Press = 16.5853842765046
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -8046.6473     -8046.6473     -8120.4415     -8120.4415      285.59091      285.59091      24105.366      24105.366     -1683.6177     -1683.6177    
     15000  -8043.5037     -8043.5037     -8120.9037     -8120.9037      299.54604      299.54604      24070.685      24070.685      1177.9457      1177.9457    
Loop time of 96.6618 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.851 hours/ns, 10.345 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.176     | 96.176     | 96.176     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073116   | 0.073116   | 0.073116   |   0.0 |  0.08
Output  | 0.00017016 | 0.00017016 | 0.00017016 |   0.0 |  0.00
Modify  | 0.358      | 0.358      | 0.358      |   0.0 |  0.37
Other   |            | 0.05406    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116148 ave      116148 max      116148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116148
Ave neighs/atom = 58.074
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.42198196775, Press = 9.0658262845554
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -8043.5037     -8043.5037     -8120.9037     -8120.9037      299.54604      299.54604      24070.685      24070.685      1177.9457      1177.9457    
     16000  -8044.6519     -8044.6519     -8120.3392     -8120.3392      292.91751      292.91751      24106.624      24106.624     -1676.2349     -1676.2349    
Loop time of 96.7661 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.879 hours/ns, 10.334 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.281     | 96.281     | 96.281     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072797   | 0.072797   | 0.072797   |   0.0 |  0.08
Output  | 0.0001698  | 0.0001698  | 0.0001698  |   0.0 |  0.00
Modify  | 0.35806    | 0.35806    | 0.35806    |   0.0 |  0.37
Other   |            | 0.05354    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116206 ave      116206 max      116206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116206
Ave neighs/atom = 58.103
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.657647361926, Press = 19.638638484518
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -8044.6519     -8044.6519     -8120.3392     -8120.3392      292.91751      292.91751      24106.624      24106.624     -1676.2349     -1676.2349    
     17000  -8041.7654     -8041.7654     -8120.548      -8120.548       304.89675      304.89675      24085.684      24085.684      79.449612      79.449612    
Loop time of 96.5167 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.810 hours/ns, 10.361 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.031     | 96.031     | 96.031     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073435   | 0.073435   | 0.073435   |   0.0 |  0.08
Output  | 0.00016931 | 0.00016931 | 0.00016931 |   0.0 |  0.00
Modify  | 0.35856    | 0.35856    | 0.35856    |   0.0 |  0.37
Other   |            | 0.05386    |            |       |  0.06

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

Total # of neighbors = 116190
Ave neighs/atom = 58.095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.644813763013, Press = 1.97864113651541
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -8041.7654     -8041.7654     -8120.548      -8120.548       304.89675      304.89675      24085.684      24085.684      79.449612      79.449612    
     18000  -8045.5018     -8045.5018     -8119.4593     -8119.4593      286.22323      286.22323      24077.441      24077.441      701.83439      701.83439    
Loop time of 96.6172 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.838 hours/ns, 10.350 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.132     | 96.132     | 96.132     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073368   | 0.073368   | 0.073368   |   0.0 |  0.08
Output  | 0.00017269 | 0.00017269 | 0.00017269 |   0.0 |  0.00
Modify  | 0.35722    | 0.35722    | 0.35722    |   0.0 |  0.37
Other   |            | 0.0542     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116148 ave      116148 max      116148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116148
Ave neighs/atom = 58.074
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.681696487386, Press = 14.2356193037175
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -8045.5018     -8045.5018     -8119.4593     -8119.4593      286.22323      286.22323      24077.441      24077.441      701.83439      701.83439    
     19000  -8042.5153     -8042.5153     -8118.2513     -8118.2513      293.10647      293.10647      24094.293      24094.293     -306.90929     -306.90929    
Loop time of 96.6148 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.837 hours/ns, 10.350 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.131     | 96.131     | 96.131     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072877   | 0.072877   | 0.072877   |   0.0 |  0.08
Output  | 0.00016995 | 0.00016995 | 0.00016995 |   0.0 |  0.00
Modify  | 0.35732    | 0.35732    | 0.35732    |   0.0 |  0.37
Other   |            | 0.0537     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116206 ave      116206 max      116206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116206
Ave neighs/atom = 58.103
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.778828699182, Press = 6.66175837797857
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -8042.5153     -8042.5153     -8118.2513     -8118.2513      293.10647      293.10647      24094.293      24094.293     -306.90929     -306.90929    
     20000  -8042.9316     -8042.9316     -8116.2875     -8116.2875      283.8949       283.8949       24079.06       24079.06       980.48027      980.48027    
Loop time of 96.5747 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.826 hours/ns, 10.355 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.09      | 96.09      | 96.09      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073421   | 0.073421   | 0.073421   |   0.0 |  0.08
Output  | 0.00017152 | 0.00017152 | 0.00017152 |   0.0 |  0.00
Modify  | 0.35759    | 0.35759    | 0.35759    |   0.0 |  0.37
Other   |            | 0.05392    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116186 ave      116186 max      116186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116186
Ave neighs/atom = 58.093
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.684022884797, Press = 11.4365255629828
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -8042.9316     -8042.9316     -8116.2875     -8116.2875      283.8949       283.8949       24079.06       24079.06       980.48027      980.48027    
     21000  -8044.5104     -8044.5104     -8119.4558     -8119.4558      290.04664      290.04664      24105.826      24105.826     -1482.23       -1482.23      
Loop time of 96.7251 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.868 hours/ns, 10.339 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.24      | 96.24      | 96.24      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073985   | 0.073985   | 0.073985   |   0.0 |  0.08
Output  | 0.00016978 | 0.00016978 | 0.00016978 |   0.0 |  0.00
Modify  | 0.3575     | 0.3575     | 0.3575     |   0.0 |  0.37
Other   |            | 0.05386    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2947 ave        2947 max        2947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116196 ave      116196 max      116196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116196
Ave neighs/atom = 58.098
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.679106891785, Press = 3.8202194606352
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -8044.5104     -8044.5104     -8119.4558     -8119.4558      290.04664      290.04664      24105.826      24105.826     -1482.23       -1482.23      
     22000  -8043.2977     -8043.2977     -8119.4932     -8119.4932      294.8846       294.8846       24047.708      24047.708      3096.0654      3096.0654    
Loop time of 96.5647 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.824 hours/ns, 10.356 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.08      | 96.08      | 96.08      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07309    | 0.07309    | 0.07309    |   0.0 |  0.08
Output  | 0.00017066 | 0.00017066 | 0.00017066 |   0.0 |  0.00
Modify  | 0.35767    | 0.35767    | 0.35767    |   0.0 |  0.37
Other   |            | 0.05358    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116160 ave      116160 max      116160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116160
Ave neighs/atom = 58.08
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.478883206876, Press = 13.0674855842901
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8043.2977     -8043.2977     -8119.4932     -8119.4932      294.8846       294.8846       24047.708      24047.708      3096.0654      3096.0654    
     23000  -8047.1283     -8047.1283     -8119.7358     -8119.7358      280.99843      280.99843      24116.405      24116.405     -2216.9917     -2216.9917    
Loop time of 96.5392 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.816 hours/ns, 10.358 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.055     | 96.055     | 96.055     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073383   | 0.073383   | 0.073383   |   0.0 |  0.08
Output  | 0.00016971 | 0.00016971 | 0.00016971 |   0.0 |  0.00
Modify  | 0.35691    | 0.35691    | 0.35691    |   0.0 |  0.37
Other   |            | 0.0538     |            |       |  0.06

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

Total # of neighbors = 116214
Ave neighs/atom = 58.107
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.435303206205, Press = 5.26483372153521
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -8047.1283     -8047.1283     -8119.7358     -8119.7358      280.99843      280.99843      24116.405      24116.405     -2216.9917     -2216.9917    
     24000  -8041.8769     -8041.8769     -8119.3643     -8119.3643      299.8841       299.8841       24058.303      24058.303      2219.3084      2219.3084    
Loop time of 96.676 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.854 hours/ns, 10.344 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.192     | 96.192     | 96.192     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073117   | 0.073117   | 0.073117   |   0.0 |  0.08
Output  | 0.00016901 | 0.00016901 | 0.00016901 |   0.0 |  0.00
Modify  | 0.35734    | 0.35734    | 0.35734    |   0.0 |  0.37
Other   |            | 0.05359    |            |       |  0.06

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

Total # of neighbors = 116154
Ave neighs/atom = 58.077
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.38468050546, Press = 8.77340088692715
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -8041.8769     -8041.8769     -8119.3643     -8119.3643      299.8841       299.8841       24058.303      24058.303      2219.3084      2219.3084    
     25000  -8044.5612     -8044.5612     -8119.9141     -8119.9141      291.62366      291.62366      24116.706      24116.706     -2368.3816     -2368.3816    
Loop time of 96.6026 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.834 hours/ns, 10.352 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.117     | 96.117     | 96.117     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073707   | 0.073707   | 0.073707   |   0.0 |  0.08
Output  | 0.00017125 | 0.00017125 | 0.00017125 |   0.0 |  0.00
Modify  | 0.35798    | 0.35798    | 0.35798    |   0.0 |  0.37
Other   |            | 0.05341    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116222 ave      116222 max      116222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116222
Ave neighs/atom = 58.111
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.402622095079, Press = 6.18085490875236
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -8044.5612     -8044.5612     -8119.9141     -8119.9141      291.62366      291.62366      24116.706      24116.706     -2368.3816     -2368.3816    
     26000  -8043.3127     -8043.3127     -8118.7649     -8118.7649      292.00784      292.00784      24060.961      24060.961      2094.9409      2094.9409    
Loop time of 96.709 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.864 hours/ns, 10.340 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.224     | 96.224     | 96.224     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073094   | 0.073094   | 0.073094   |   0.0 |  0.08
Output  | 0.00017089 | 0.00017089 | 0.00017089 |   0.0 |  0.00
Modify  | 0.35799    | 0.35799    | 0.35799    |   0.0 |  0.37
Other   |            | 0.05387    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116172 ave      116172 max      116172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116172
Ave neighs/atom = 58.086
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.369102528239, Press = 6.23781570284824
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -8043.3127     -8043.3127     -8118.7649     -8118.7649      292.00784      292.00784      24060.961      24060.961      2094.9409      2094.9409    
     27000  -8042.6983     -8042.6983     -8119.8558     -8119.8558      298.60739      298.60739      24111.563      24111.563     -1879.8552     -1879.8552    
Loop time of 107.04 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.807 ns/day, 29.733 hours/ns, 9.342 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.49     | 106.49     | 106.49     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079044   | 0.079044   | 0.079044   |   0.0 |  0.07
Output  | 0.00023382 | 0.00023382 | 0.00023382 |   0.0 |  0.00
Modify  | 0.41434    | 0.41434    | 0.41434    |   0.0 |  0.39
Other   |            | 0.0581     |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116202 ave      116202 max      116202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116202
Ave neighs/atom = 58.101
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.488496378603, Press = 6.34011305112972
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -8042.6983     -8042.6983     -8119.8558     -8119.8558      298.60739      298.60739      24111.563      24111.563     -1879.8552     -1879.8552    
     28000  -8046.9912     -8046.9912     -8120.6361     -8120.6361      285.01351      285.01351      24062.455      24062.455      1617.6369      1617.6369    
Loop time of 113.002 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.389 hours/ns, 8.849 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.41     | 112.41     | 112.41     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083695   | 0.083695   | 0.083695   |   0.0 |  0.07
Output  | 0.00026962 | 0.00026962 | 0.00026962 |   0.0 |  0.00
Modify  | 0.44532    | 0.44532    | 0.44532    |   0.0 |  0.39
Other   |            | 0.06168    |            |       |  0.05

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

Total # of neighbors = 116160
Ave neighs/atom = 58.08
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.445508345927, Press = 5.52878169541371
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -8046.9912     -8046.9912     -8120.6361     -8120.6361      285.01351      285.01351      24062.455      24062.455      1617.6369      1617.6369    
     29000  -8043.4291     -8043.4291     -8120.2385     -8120.2385      297.2601       297.2601       24113.014      24113.014     -2100.8185     -2100.8185    
Loop time of 103.863 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.851 hours/ns, 9.628 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.33     | 103.33     | 103.33     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077138   | 0.077138   | 0.077138   |   0.0 |  0.07
Output  | 0.00016865 | 0.00016865 | 0.00016865 |   0.0 |  0.00
Modify  | 0.39662    | 0.39662    | 0.39662    |   0.0 |  0.38
Other   |            | 0.05765    |            |       |  0.06

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

Total # of neighbors = 116216
Ave neighs/atom = 58.108
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.31768117155, Press = 5.93823821760815
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -8043.4291     -8043.4291     -8120.2385     -8120.2385      297.2601       297.2601       24113.014      24113.014     -2100.8185     -2100.8185    
     30000  -8044.7415     -8044.7415     -8120.1047     -8120.1047      291.66341      291.66341      24042.069      24042.069      3330.51        3330.51      
Loop time of 95.9815 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.900 ns/day, 26.662 hours/ns, 10.419 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.502     | 95.502     | 95.502     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07114    | 0.07114    | 0.07114    |   0.0 |  0.07
Output  | 0.00016873 | 0.00016873 | 0.00016873 |   0.0 |  0.00
Modify  | 0.35301    | 0.35301    | 0.35301    |   0.0 |  0.37
Other   |            | 0.055      |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116184 ave      116184 max      116184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116184
Ave neighs/atom = 58.092
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.313563604528, Press = 3.91965091573552
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -8044.7415     -8044.7415     -8120.1047     -8120.1047      291.66341      291.66341      24042.069      24042.069      3330.51        3330.51      
     31000  -8044.9287     -8044.9287     -8120.3894     -8120.3894      292.04093      292.04093      24118.952      24118.952     -2622.5928     -2622.5928    
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
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.71     | 107.71     | 107.71     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081154   | 0.081154   | 0.081154   |   0.0 |  0.07
Output  | 0.00020236 | 0.00020236 | 0.00020236 |   0.0 |  0.00
Modify  | 0.42383    | 0.42383    | 0.42383    |   0.0 |  0.39
Other   |            | 0.06021    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2951 ave        2951 max        2951 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116214 ave      116214 max      116214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116214
Ave neighs/atom = 58.107
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.179902475599, Press = 8.20213498948126
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -8044.9287     -8044.9287     -8120.3894     -8120.3894      292.04093      292.04093      24118.952      24118.952     -2622.5928     -2622.5928    
     32000  -8046.2098     -8046.2098     -8122.1632     -8122.1632      293.94727      293.94727      24075.832      24075.832      571.35426      571.35426    
Loop time of 113.669 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.575 hours/ns, 8.797 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.08     | 113.08     | 113.08     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083514   | 0.083514   | 0.083514   |   0.0 |  0.07
Output  | 0.00017063 | 0.00017063 | 0.00017063 |   0.0 |  0.00
Modify  | 0.44661    | 0.44661    | 0.44661    |   0.0 |  0.39
Other   |            | 0.06152    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116166 ave      116166 max      116166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116166
Ave neighs/atom = 58.083
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.164008423295, Press = 3.36532104230281
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -8046.2098     -8046.2098     -8122.1632     -8122.1632      293.94727      293.94727      24075.832      24075.832      571.35426      571.35426    
     33000  -8046.5382     -8046.5382     -8120.2584     -8120.2584      285.3045       285.3045       24082.26       24082.26       190.25659      190.25659    
Loop time of 99.281 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.578 hours/ns, 10.072 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.779     | 98.779     | 98.779     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073887   | 0.073887   | 0.073887   |   0.0 |  0.07
Output  | 0.00016795 | 0.00016795 | 0.00016795 |   0.0 |  0.00
Modify  | 0.37211    | 0.37211    | 0.37211    |   0.0 |  0.37
Other   |            | 0.056      |            |       |  0.06

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

Total # of neighbors = 116184
Ave neighs/atom = 58.092
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.120550734032, Press = 6.17005168041756
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -8046.5382     -8046.5382     -8120.2584     -8120.2584      285.3045       285.3045       24082.26       24082.26       190.25659      190.25659    
     34000  -8038.7905     -8038.7905     -8117.3508     -8117.3508      304.03613      304.03613      24104.467      24104.467     -1082.275      -1082.275     
Loop time of 100.622 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.859 ns/day, 27.951 hours/ns, 9.938 timesteps/s
99.9% 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.11     | 100.11     | 100.11     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075405   | 0.075405   | 0.075405   |   0.0 |  0.07
Output  | 0.00016851 | 0.00016851 | 0.00016851 |   0.0 |  0.00
Modify  | 0.38102    | 0.38102    | 0.38102    |   0.0 |  0.38
Other   |            | 0.05663    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116156 ave      116156 max      116156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116156
Ave neighs/atom = 58.078
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.171407965879, Press = 3.16254856941612
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -8038.7905     -8038.7905     -8117.3508     -8117.3508      304.03613      304.03613      24104.467      24104.467     -1082.275      -1082.275     
     35000  -8045.1723     -8045.1723     -8119.8771     -8119.8771      289.11524      289.11524      24061.897      24061.897      1795.235       1795.235     
Loop time of 104.822 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.117 hours/ns, 9.540 timesteps/s
99.9% 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.28     | 104.28     | 104.28     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078814   | 0.078814   | 0.078814   |   0.0 |  0.08
Output  | 0.00020543 | 0.00020543 | 0.00020543 |   0.0 |  0.00
Modify  | 0.40195    | 0.40195    | 0.40195    |   0.0 |  0.38
Other   |            | 0.058      |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116212 ave      116212 max      116212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116212
Ave neighs/atom = 58.106
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.216985628407, Press = 6.30790798311358
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -8045.1723     -8045.1723     -8119.8771     -8119.8771      289.11524      289.11524      24061.897      24061.897      1795.235       1795.235     
     36000  -8040.4065     -8040.4065     -8117.9896     -8117.9896      300.25461      300.25461      24139.55       24139.55      -4006.7104     -4006.7104    
Loop time of 113.326 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.479 hours/ns, 8.824 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.74     | 112.74     | 112.74     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083663   | 0.083663   | 0.083663   |   0.0 |  0.07
Output  | 0.00022937 | 0.00022937 | 0.00022937 |   0.0 |  0.00
Modify  | 0.44504    | 0.44504    | 0.44504    |   0.0 |  0.39
Other   |            | 0.06173    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116182 ave      116182 max      116182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116182
Ave neighs/atom = 58.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.301963650433, Press = 2.15602343902256
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -8040.4065     -8040.4065     -8117.9896     -8117.9896      300.25461      300.25461      24139.55       24139.55      -4006.7104     -4006.7104    
     37000  -8042.6606     -8042.6606     -8118.9573     -8118.9573      295.27593      295.27593      24049.117      24049.117      3083.3803      3083.3803    
Loop time of 113.3 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.472 hours/ns, 8.826 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.71     | 112.71     | 112.71     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083182   | 0.083182   | 0.083182   |   0.0 |  0.07
Output  | 0.00021148 | 0.00021148 | 0.00021148 |   0.0 |  0.00
Modify  | 0.44644    | 0.44644    | 0.44644    |   0.0 |  0.39
Other   |            | 0.06212    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116150 ave      116150 max      116150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116150
Ave neighs/atom = 58.075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.279916959946, Press = 5.57504357226924
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -8042.6606     -8042.6606     -8118.9573     -8118.9573      295.27593      295.27593      24049.117      24049.117      3083.3803      3083.3803    
     38000  -8043.7725     -8043.7725     -8118.4529     -8118.4529      289.02084      289.02084      24101.058      24101.058     -1005.9209     -1005.9209    
Loop time of 113.285 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.468 hours/ns, 8.827 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.69     | 112.69     | 112.69     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083248   | 0.083248   | 0.083248   |   0.0 |  0.07
Output  | 0.00021193 | 0.00021193 | 0.00021193 |   0.0 |  0.00
Modify  | 0.44589    | 0.44589    | 0.44589    |   0.0 |  0.39
Other   |            | 0.06237    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116188 ave      116188 max      116188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116188
Ave neighs/atom = 58.094
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.236597438067, Press = 4.14902064061629
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -8043.7725     -8043.7725     -8118.4529     -8118.4529      289.02084      289.02084      24101.058      24101.058     -1005.9209     -1005.9209    
     39000  -8045.6102     -8045.6102     -8119.7634     -8119.7634      286.98075      286.98075      24066.553      24066.553      1396.1385      1396.1385    
Loop time of 100.332 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.861 ns/day, 27.870 hours/ns, 9.967 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.821     | 99.821     | 99.821     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07529    | 0.07529    | 0.07529    |   0.0 |  0.08
Output  | 0.0001696  | 0.0001696  | 0.0001696  |   0.0 |  0.00
Modify  | 0.37873    | 0.37873    | 0.37873    |   0.0 |  0.38
Other   |            | 0.05696    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116170 ave      116170 max      116170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116170
Ave neighs/atom = 58.085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.162538581493, Press = 3.92526453265131
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -8045.6102     -8045.6102     -8119.7634     -8119.7634      286.98075      286.98075      24066.553      24066.553      1396.1385      1396.1385    
     40000  -8042.7001     -8042.7001     -8118.5725     -8118.5725      293.63419      293.63419      24101.52       24101.52      -1052.715      -1052.715     
Loop time of 108.098 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.799 ns/day, 30.027 hours/ns, 9.251 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.54     | 107.54     | 107.54     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080497   | 0.080497   | 0.080497   |   0.0 |  0.07
Output  | 0.00016852 | 0.00016852 | 0.00016852 |   0.0 |  0.00
Modify  | 0.41807    | 0.41807    | 0.41807    |   0.0 |  0.39
Other   |            | 0.05955    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116176 ave      116176 max      116176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116176
Ave neighs/atom = 58.088
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.100177513558, Press = 4.37143110798644
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -8042.7001     -8042.7001     -8118.5725     -8118.5725      293.63419      293.63419      24101.52       24101.52      -1052.715      -1052.715     
     41000  -8044.8392     -8044.8392     -8120.8506     -8120.8506      294.17203      294.17203      24067.704      24067.704      1317.2767      1317.2767    
Loop time of 113.073 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.409 hours/ns, 8.844 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.48     | 112.48     | 112.48     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083533   | 0.083533   | 0.083533   |   0.0 |  0.07
Output  | 0.00016963 | 0.00016963 | 0.00016963 |   0.0 |  0.00
Modify  | 0.4457     | 0.4457     | 0.4457     |   0.0 |  0.39
Other   |            | 0.06146    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116182 ave      116182 max      116182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116182
Ave neighs/atom = 58.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.077286673587, Press = 2.67081186387078
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -8044.8392     -8044.8392     -8120.8506     -8120.8506      294.17203      294.17203      24067.704      24067.704      1317.2767      1317.2767    
     42000  -8044.126      -8044.126      -8119.3184     -8119.3184      291.00223      291.00223      24101.724      24101.724     -1157.2745     -1157.2745    
Loop time of 113.132 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.426 hours/ns, 8.839 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.54     | 112.54     | 112.54     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08354    | 0.08354    | 0.08354    |   0.0 |  0.07
Output  | 0.0002176  | 0.0002176  | 0.0002176  |   0.0 |  0.00
Modify  | 0.44782    | 0.44782    | 0.44782    |   0.0 |  0.40
Other   |            | 0.06219    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116176 ave      116176 max      116176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116176
Ave neighs/atom = 58.088
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.091112151402, Press = 5.86283292975407
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -8044.126      -8044.126      -8119.3184     -8119.3184      291.00223      291.00223      24101.724      24101.724     -1157.2745     -1157.2745    
     43000  -8043.2611     -8043.2611     -8117.5436     -8117.5436      287.48121      287.48121      24078.371      24078.371      822.41506      822.41506    
Loop time of 113.301 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.473 hours/ns, 8.826 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.7      | 112.7      | 112.7      |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083912   | 0.083912   | 0.083912   |   0.0 |  0.07
Output  | 0.00017014 | 0.00017014 | 0.00017014 |   0.0 |  0.00
Modify  | 0.45104    | 0.45104    | 0.45104    |   0.0 |  0.40
Other   |            | 0.06156    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116166 ave      116166 max      116166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116166
Ave neighs/atom = 58.083
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.075666743285, Press = 2.07356784364441
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -8043.2611     -8043.2611     -8117.5436     -8117.5436      287.48121      287.48121      24078.371      24078.371      822.41506      822.41506    
     44000  -8042.8805     -8042.8805     -8120.4023     -8120.4023      300.01721      300.01721      24087.043      24087.043     -48.083282     -48.083282    
Loop time of 113.37 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.492 hours/ns, 8.821 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.78     | 112.78     | 112.78     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08418    | 0.08418    | 0.08418    |   0.0 |  0.07
Output  | 0.00028122 | 0.00028122 | 0.00028122 |   0.0 |  0.00
Modify  | 0.44732    | 0.44732    | 0.44732    |   0.0 |  0.39
Other   |            | 0.06148    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116196 ave      116196 max      116196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116196
Ave neighs/atom = 58.098
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.088420766252, Press = 4.87663060310636
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -8042.8805     -8042.8805     -8120.4023     -8120.4023      300.01721      300.01721      24087.043      24087.043     -48.083282     -48.083282    
     45000  -8040.729      -8040.729      -8118.7401     -8118.7401      301.9108       301.9108       24097.899      24097.899     -647.68218     -647.68218    
Loop time of 113.21 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.447 hours/ns, 8.833 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.61     | 112.61     | 112.61     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08355    | 0.08355    | 0.08355    |   0.0 |  0.07
Output  | 0.0002176  | 0.0002176  | 0.0002176  |   0.0 |  0.00
Modify  | 0.44988    | 0.44988    | 0.44988    |   0.0 |  0.40
Other   |            | 0.06195    |            |       |  0.05

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

Total # of neighbors = 116156
Ave neighs/atom = 58.078
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.070402656523, Press = 2.90318291167087
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -8040.729      -8040.729      -8118.7401     -8118.7401      301.9108       301.9108       24097.899      24097.899     -647.68218     -647.68218    
     46000  -8044.4393     -8044.4393     -8119.0162     -8119.0162      288.62057      288.62057      24078.865      24078.865      516.7809       516.7809     
Loop time of 113.221 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.450 hours/ns, 8.832 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.63     | 112.63     | 112.63     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083187   | 0.083187   | 0.083187   |   0.0 |  0.07
Output  | 0.00017353 | 0.00017353 | 0.00017353 |   0.0 |  0.00
Modify  | 0.44455    | 0.44455    | 0.44455    |   0.0 |  0.39
Other   |            | 0.06178    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116184 ave      116184 max      116184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116184
Ave neighs/atom = 58.092
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.108230316291, Press = 3.56557474538979
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -8044.4393     -8044.4393     -8119.0162     -8119.0162      288.62057      288.62057      24078.865      24078.865      516.7809       516.7809     
     47000  -8041.2642     -8041.2642     -8119.4514     -8119.4514      302.59234      302.59234      24096.356      24096.356     -729.09358     -729.09358    
Loop time of 113.038 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.400 hours/ns, 8.847 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.46     | 112.46     | 112.46     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082511   | 0.082511   | 0.082511   |   0.0 |  0.07
Output  | 0.00022231 | 0.00022231 | 0.00022231 |   0.0 |  0.00
Modify  | 0.43777    | 0.43777    | 0.43777    |   0.0 |  0.39
Other   |            | 0.06081    |            |       |  0.05

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

Total # of neighbors = 116210
Ave neighs/atom = 58.105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.157105618417, Press = 3.051060193093
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8041.2642     -8041.2642     -8119.4514     -8119.4514      302.59234      302.59234      24096.356      24096.356     -729.09358     -729.09358    
     48000  -8045.7369     -8045.7369     -8120.073      -8120.073       287.68835      287.68835      24074.565      24074.565      703.3195       703.3195     
Loop time of 113.06 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.406 hours/ns, 8.845 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.47     | 112.47     | 112.47     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082471   | 0.082471   | 0.082471   |   0.0 |  0.07
Output  | 0.00017199 | 0.00017199 | 0.00017199 |   0.0 |  0.00
Modify  | 0.44153    | 0.44153    | 0.44153    |   0.0 |  0.39
Other   |            | 0.06139    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2946 ave        2946 max        2946 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116178 ave      116178 max      116178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116178
Ave neighs/atom = 58.089
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.172940324186, Press = 2.91370830592479
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8045.7369     -8045.7369     -8120.073      -8120.073       287.68835      287.68835      24074.565      24074.565      703.3195       703.3195     
     49000  -8039.9068     -8039.9068     -8118.5946     -8118.5946      304.53         304.53         24104.568      24104.568     -1218.6492     -1218.6492    
Loop time of 112.112 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.771 ns/day, 31.142 hours/ns, 8.920 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.53     | 111.53     | 111.53     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08268    | 0.08268    | 0.08268    |   0.0 |  0.07
Output  | 0.00016965 | 0.00016965 | 0.00016965 |   0.0 |  0.00
Modify  | 0.43912    | 0.43912    | 0.43912    |   0.0 |  0.39
Other   |            | 0.06125    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116240 ave      116240 max      116240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116240
Ave neighs/atom = 58.12
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.197622241709, Press = 3.05439034588829
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -8039.9068     -8039.9068     -8118.5946     -8118.5946      304.53         304.53         24104.568      24104.568     -1218.6492     -1218.6492    
     50000  -8044.1402     -8044.1402     -8118.4096     -8118.4096      287.43049      287.43049      24061.667      24061.667      1919.6863      1919.6863    
Loop time of 100.843 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.857 ns/day, 28.012 hours/ns, 9.916 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.33     | 100.33     | 100.33     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076195   | 0.076195   | 0.076195   |   0.0 |  0.08
Output  | 0.00023559 | 0.00023559 | 0.00023559 |   0.0 |  0.00
Modify  | 0.38378    | 0.38378    | 0.38378    |   0.0 |  0.38
Other   |            | 0.05681    |            |       |  0.06

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

Total # of neighbors = 116206
Ave neighs/atom = 58.103
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.253665810302, Press = 2.92134530458789
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -8044.1402     -8044.1402     -8118.4096     -8118.4096      287.43049      287.43049      24061.667      24061.667      1919.6863      1919.6863    
     51000  -8044.5322     -8044.5322     -8119.1221     -8119.1221      288.67055      288.67055      24114.358      24114.358     -2251.1752     -2251.1752    
Loop time of 113.901 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.759 ns/day, 31.639 hours/ns, 8.780 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.3      | 113.3      | 113.3      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084277   | 0.084277   | 0.084277   |   0.0 |  0.07
Output  | 0.00016936 | 0.00016936 | 0.00016936 |   0.0 |  0.00
Modify  | 0.45049    | 0.45049    | 0.45049    |   0.0 |  0.40
Other   |            | 0.06238    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116218 ave      116218 max      116218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116218
Ave neighs/atom = 58.109
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.22707897074, Press = 2.88006428819786
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -8044.5322     -8044.5322     -8119.1221     -8119.1221      288.67055      288.67055      24114.358      24114.358     -2251.1752     -2251.1752    
     52000  -8042.2461     -8042.2461     -8119.064      -8119.064       297.29303      297.29303      24044.611      24044.611      3266.2379      3266.2379    
Loop time of 113.904 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.759 ns/day, 31.640 hours/ns, 8.779 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.3      | 113.3      | 113.3      |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084945   | 0.084945   | 0.084945   |   0.0 |  0.07
Output  | 0.00016983 | 0.00016983 | 0.00016983 |   0.0 |  0.00
Modify  | 0.45273    | 0.45273    | 0.45273    |   0.0 |  0.40
Other   |            | 0.06234    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116160 ave      116160 max      116160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116160
Ave neighs/atom = 58.08
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.25853658653, Press = 2.18592526882737
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -8042.2461     -8042.2461     -8119.064      -8119.064       297.29303      297.29303      24044.611      24044.611      3266.2379      3266.2379    
     53000  -8043.5956     -8043.5956     -8120.0827     -8120.0827      296.0129       296.0129       24122.208      24122.208     -2781.5377     -2781.5377    
Loop time of 113.491 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.525 hours/ns, 8.811 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.9      | 112.9      | 112.9      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083909   | 0.083909   | 0.083909   |   0.0 |  0.07
Output  | 0.00016941 | 0.00016941 | 0.00016941 |   0.0 |  0.00
Modify  | 0.44838    | 0.44838    | 0.44838    |   0.0 |  0.40
Other   |            | 0.06179    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116214 ave      116214 max      116214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116214
Ave neighs/atom = 58.107
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.260769210137, Press = 3.82309476404059
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -8043.5956     -8043.5956     -8120.0827     -8120.0827      296.0129       296.0129       24122.208      24122.208     -2781.5377     -2781.5377    
     54000  -8041.825      -8041.825      -8118.7235     -8118.7235      297.60501      297.60501      24074.2        24074.2        1043.5356      1043.5356    
Loop time of 113.822 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.759 ns/day, 31.617 hours/ns, 8.786 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.23     | 113.23     | 113.23     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084578   | 0.084578   | 0.084578   |   0.0 |  0.07
Output  | 0.00016217 | 0.00016217 | 0.00016217 |   0.0 |  0.00
Modify  | 0.44639    | 0.44639    | 0.44639    |   0.0 |  0.39
Other   |            | 0.06188    |            |       |  0.05

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

Total # of neighbors = 116164
Ave neighs/atom = 58.082
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.31974621986, Press = 2.04498254155886
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -8041.825      -8041.825      -8118.7235     -8118.7235      297.60501      297.60501      24074.2        24074.2        1043.5356      1043.5356    
     55000  -8044.1353     -8044.1353     -8119.1271     -8119.1271      290.2261       290.2261       24091.581      24091.581     -354.59064     -354.59064    
Loop time of 99.166 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.546 hours/ns, 10.084 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.661     | 98.661     | 98.661     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074879   | 0.074879   | 0.074879   |   0.0 |  0.08
Output  | 0.00016796 | 0.00016796 | 0.00016796 |   0.0 |  0.00
Modify  | 0.37332    | 0.37332    | 0.37332    |   0.0 |  0.38
Other   |            | 0.05665    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116186 ave      116186 max      116186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116186
Ave neighs/atom = 58.093
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.328273639684, Press = 3.13015412069037
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -8044.1353     -8044.1353     -8119.1271     -8119.1271      290.2261       290.2261       24091.581      24091.581     -354.59064     -354.59064    
     56000  -8047.3664     -8047.3664     -8119.7415     -8119.7415      280.09908      280.09908      24080.069      24080.069      318.0748       318.0748     
Loop time of 96.4355 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.788 hours/ns, 10.370 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.947     | 95.947     | 95.947     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073229   | 0.073229   | 0.073229   |   0.0 |  0.08
Output  | 0.00016947 | 0.00016947 | 0.00016947 |   0.0 |  0.00
Modify  | 0.35876    | 0.35876    | 0.35876    |   0.0 |  0.37
Other   |            | 0.05618    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116182 ave      116182 max      116182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116182
Ave neighs/atom = 58.091
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.327080219467, Press = 2.12520613519245
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -8047.3664     -8047.3664     -8119.7415     -8119.7415      280.09908      280.09908      24080.069      24080.069      318.0748       318.0748     
     57000  -8043.6255     -8043.6255     -8118.3535     -8118.3535      289.20534      289.20534      24083.033      24083.033      378.92207      378.92207    
Loop time of 96.233 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.731 hours/ns, 10.391 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.745     | 95.745     | 95.745     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072487   | 0.072487   | 0.072487   |   0.0 |  0.08
Output  | 0.00016875 | 0.00016875 | 0.00016875 |   0.0 |  0.00
Modify  | 0.35891    | 0.35891    | 0.35891    |   0.0 |  0.37
Other   |            | 0.05633    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116160 ave      116160 max      116160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116160
Ave neighs/atom = 58.08
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.275808148623, Press = 3.49654129779182
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -8043.6255     -8043.6255     -8118.3535     -8118.3535      289.20534      289.20534      24083.033      24083.033      378.92207      378.92207    
     58000  -8047.1089     -8047.1089     -8120.6347     -8120.6347      284.55227      284.55227      24098.418      24098.418     -1206.9224     -1206.9224    
Loop time of 96.2063 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.724 hours/ns, 10.394 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.719     | 95.719     | 95.719     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07256    | 0.07256    | 0.07256    |   0.0 |  0.08
Output  | 0.00016972 | 0.00016972 | 0.00016972 |   0.0 |  0.00
Modify  | 0.35794    | 0.35794    | 0.35794    |   0.0 |  0.37
Other   |            | 0.0563     |            |       |  0.06

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

Total # of neighbors = 116200
Ave neighs/atom = 58.1
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.262954875767, Press = 0.731124532186346
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -8047.1089     -8047.1089     -8120.6347     -8120.6347      284.55227      284.55227      24098.418      24098.418     -1206.9224     -1206.9224    
     59000  -8043.1338     -8043.1338     -8120.4033     -8120.4033      299.04068      299.04068      24069.49       24069.49       1371.6813      1371.6813    
Loop time of 96.2377 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.733 hours/ns, 10.391 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.75      | 95.75      | 95.75      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072911   | 0.072911   | 0.072911   |   0.0 |  0.08
Output  | 0.00021072 | 0.00021072 | 0.00021072 |   0.0 |  0.00
Modify  | 0.35864    | 0.35864    | 0.35864    |   0.0 |  0.37
Other   |            | 0.05617    |            |       |  0.06

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

Total # of neighbors = 116160
Ave neighs/atom = 58.08
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.207739915413, Press = 3.94814193860903
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -8043.1338     -8043.1338     -8120.4033     -8120.4033      299.04068      299.04068      24069.49       24069.49       1371.6813      1371.6813    
     60000  -8045.1709     -8045.1709     -8120.0624     -8120.0624      289.83784      289.83784      24103.87       24103.87      -1476.2237     -1476.2237    
Loop time of 96.1543 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.710 hours/ns, 10.400 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.667     | 95.667     | 95.667     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072777   | 0.072777   | 0.072777   |   0.0 |  0.08
Output  | 0.000169   | 0.000169   | 0.000169   |   0.0 |  0.00
Modify  | 0.35806    | 0.35806    | 0.35806    |   0.0 |  0.37
Other   |            | 0.05595    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2946 ave        2946 max        2946 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116206 ave      116206 max      116206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116206
Ave neighs/atom = 58.103
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.216056898757, Press = 1.57859360936497
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -8045.1709     -8045.1709     -8120.0624     -8120.0624      289.83784      289.83784      24103.87       24103.87      -1476.2237     -1476.2237    
     61000  -8043.2213     -8043.2213     -8118.7471     -8118.7471      292.29258      292.29258      24067.041      24067.041      1698.67        1698.67      
Loop time of 104.733 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.19     | 104.19     | 104.19     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078695   | 0.078695   | 0.078695   |   0.0 |  0.08
Output  | 0.00021792 | 0.00021792 | 0.00021792 |   0.0 |  0.00
Modify  | 0.40471    | 0.40471    | 0.40471    |   0.0 |  0.39
Other   |            | 0.05943    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116184 ave      116184 max      116184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116184
Ave neighs/atom = 58.092
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.211812749728, Press = 2.81224823685846
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -8043.2213     -8043.2213     -8118.7471     -8118.7471      292.29258      292.29258      24067.041      24067.041      1698.67        1698.67      
     62000  -8045.7174     -8045.7174     -8120.7909     -8120.7909      290.54231      290.54231      24101.403      24101.403     -1287.5441     -1287.5441    
Loop time of 111.35 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.776 ns/day, 30.931 hours/ns, 8.981 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.77     | 110.77     | 110.77     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082515   | 0.082515   | 0.082515   |   0.0 |  0.07
Output  | 0.00017    | 0.00017    | 0.00017    |   0.0 |  0.00
Modify  | 0.43821    | 0.43821    | 0.43821    |   0.0 |  0.39
Other   |            | 0.0616     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116148 ave      116148 max      116148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116148
Ave neighs/atom = 58.074
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.211601062462, Press = 1.66897345881568
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -8045.7174     -8045.7174     -8120.7909     -8120.7909      290.54231      290.54231      24101.403      24101.403     -1287.5441     -1287.5441    
     63000  -8042.239      -8042.239      -8120.5041     -8120.5041      302.8943       302.8943       24046.271      24046.271      3029.8506      3029.8506    
Loop time of 113.751 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.16     | 113.16     | 113.16     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084576   | 0.084576   | 0.084576   |   0.0 |  0.07
Output  | 0.00017128 | 0.00017128 | 0.00017128 |   0.0 |  0.00
Modify  | 0.44786    | 0.44786    | 0.44786    |   0.0 |  0.39
Other   |            | 0.06207    |            |       |  0.05

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

Total # of neighbors = 116150
Ave neighs/atom = 58.075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.161200210542, Press = 3.0955290995054
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -8042.239      -8042.239      -8120.5041     -8120.5041      302.8943       302.8943       24046.271      24046.271      3029.8506      3029.8506    
     64000  -8044.3804     -8044.3804     -8118.9728     -8118.9728      288.68018      288.68018      24146.87       24146.87      -4556.203      -4556.203     
Loop time of 109.921 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.786 ns/day, 30.533 hours/ns, 9.097 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.35     | 109.35     | 109.35     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081669   | 0.081669   | 0.081669   |   0.0 |  0.07
Output  | 0.00016925 | 0.00016925 | 0.00016925 |   0.0 |  0.00
Modify  | 0.42604    | 0.42604    | 0.42604    |   0.0 |  0.39
Other   |            | 0.0608     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116158 ave      116158 max      116158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116158
Ave neighs/atom = 58.079
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.164327686149, Press = 1.82120941900317
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -8044.3804     -8044.3804     -8118.9728     -8118.9728      288.68018      288.68018      24146.87       24146.87      -4556.203      -4556.203     
     65000  -8043.5309     -8043.5309     -8117.5651     -8117.5651      286.51974      286.51974      24052.708      24052.708      2763.8017      2763.8017    
Loop time of 96.3952 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.776 hours/ns, 10.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    | 95.908     | 95.908     | 95.908     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072931   | 0.072931   | 0.072931   |   0.0 |  0.08
Output  | 0.00017061 | 0.00017061 | 0.00017061 |   0.0 |  0.00
Modify  | 0.35821    | 0.35821    | 0.35821    |   0.0 |  0.37
Other   |            | 0.05571    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116172 ave      116172 max      116172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116172
Ave neighs/atom = 58.086
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.213492766566, Press = 2.37099094928332
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -8043.5309     -8043.5309     -8117.5651     -8117.5651      286.51974      286.51974      24052.708      24052.708      2763.8017      2763.8017    
     66000  -8042.0569     -8042.0569     -8118.7323     -8118.7323      296.74174      296.74174      24103.856      24103.856     -1189.085      -1189.085     
Loop time of 112.647 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.06     | 112.06     | 112.06     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082943   | 0.082943   | 0.082943   |   0.0 |  0.07
Output  | 0.00023391 | 0.00023391 | 0.00023391 |   0.0 |  0.00
Modify  | 0.4432     | 0.4432     | 0.4432     |   0.0 |  0.39
Other   |            | 0.06146    |            |       |  0.05

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

Total # of neighbors = 116200
Ave neighs/atom = 58.1
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.227629179593, Press = 2.50180194634426
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -8042.0569     -8042.0569     -8118.7323     -8118.7323      296.74174      296.74174      24103.856      24103.856     -1189.085      -1189.085     
     67000  -8045.8511     -8045.8511     -8121.6439     -8121.6439      293.32594      293.32594      24071.847      24071.847      809.69893      809.69893    
Loop time of 113.608 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.558 hours/ns, 8.802 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.02     | 113.02     | 113.02     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0825     | 0.0825     | 0.0825     |   0.0 |  0.07
Output  | 0.00021531 | 0.00021531 | 0.00021531 |   0.0 |  0.00
Modify  | 0.44632    | 0.44632    | 0.44632    |   0.0 |  0.39
Other   |            | 0.06191    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116208 ave      116208 max      116208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116208
Ave neighs/atom = 58.104
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.2510219472, Press = 1.94583141151315
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -8045.8511     -8045.8511     -8121.6439     -8121.6439      293.32594      293.32594      24071.847      24071.847      809.69893      809.69893    
     68000  -8045.9489     -8045.9489     -8119.2811     -8119.2811      283.80344      283.80344      24114.113      24114.113     -2196.4168     -2196.4168    
Loop time of 113.416 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.505 hours/ns, 8.817 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.82     | 112.82     | 112.82     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083698   | 0.083698   | 0.083698   |   0.0 |  0.07
Output  | 0.00021233 | 0.00021233 | 0.00021233 |   0.0 |  0.00
Modify  | 0.44737    | 0.44737    | 0.44737    |   0.0 |  0.39
Other   |            | 0.06249    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116158 ave      116158 max      116158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116158
Ave neighs/atom = 58.079
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.24123700606, Press = 2.73791286328027
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -8045.9489     -8045.9489     -8119.2811     -8119.2811      283.80344      283.80344      24114.113      24114.113     -2196.4168     -2196.4168    
     69000  -8045.9873     -8045.9873     -8119.3474     -8119.3474      283.91116      283.91116      24046.109      24046.109      2989.7531      2989.7531    
Loop time of 113.447 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.513 hours/ns, 8.815 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.85     | 112.85     | 112.85     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082908   | 0.082908   | 0.082908   |   0.0 |  0.07
Output  | 0.00017099 | 0.00017099 | 0.00017099 |   0.0 |  0.00
Modify  | 0.44853    | 0.44853    | 0.44853    |   0.0 |  0.40
Other   |            | 0.06243    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2946 ave        2946 max        2946 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116170 ave      116170 max      116170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116170
Ave neighs/atom = 58.085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.224604604764, Press = 0.84063155106166
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -8045.9873     -8045.9873     -8119.3474     -8119.3474      283.91116      283.91116      24046.109      24046.109      2989.7531      2989.7531    
     70000  -8041.6013     -8041.6013     -8117.6199     -8117.6199      294.19997      294.19997      24108.889      24108.889     -1505.8262     -1505.8262    
Loop time of 113.474 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.521 hours/ns, 8.813 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.88     | 112.88     | 112.88     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083201   | 0.083201   | 0.083201   |   0.0 |  0.07
Output  | 0.00021082 | 0.00021082 | 0.00021082 |   0.0 |  0.00
Modify  | 0.44846    | 0.44846    | 0.44846    |   0.0 |  0.40
Other   |            | 0.062      |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116222 ave      116222 max      116222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116222
Ave neighs/atom = 58.111
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.253104247378, Press = 3.30410648909864
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -8041.6013     -8041.6013     -8117.6199     -8117.6199      294.19997      294.19997      24108.889      24108.889     -1505.8262     -1505.8262    
     71000  -8044.7032     -8044.7032     -8118.8886     -8118.8886      287.10528      287.10528      24080.735      24080.735      417.71852      417.71852    
Loop time of 113.353 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.487 hours/ns, 8.822 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.76     | 112.76     | 112.76     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08347    | 0.08347    | 0.08347    |   0.0 |  0.07
Output  | 0.00021161 | 0.00021161 | 0.00021161 |   0.0 |  0.00
Modify  | 0.44657    | 0.44657    | 0.44657    |   0.0 |  0.39
Other   |            | 0.06205    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116206 ave      116206 max      116206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116206
Ave neighs/atom = 58.103
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.274200907352, Press = 1.27478600050275
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -8044.7032     -8044.7032     -8118.8886     -8118.8886      287.10528      287.10528      24080.735      24080.735      417.71852      417.71852    
     72000  -8037.6715     -8037.6715     -8115.9688     -8115.9688      303.0184       303.0184       24090.025      24090.025      251.91551      251.91551    
Loop time of 113.507 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.530 hours/ns, 8.810 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.91     | 112.91     | 112.91     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08404    | 0.08404    | 0.08404    |   0.0 |  0.07
Output  | 0.00016891 | 0.00016891 | 0.00016891 |   0.0 |  0.00
Modify  | 0.45141    | 0.45141    | 0.45141    |   0.0 |  0.40
Other   |            | 0.06281    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116236 ave      116236 max      116236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116236
Ave neighs/atom = 58.118
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.312817280419, Press = 2.88405085632367
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -8037.6715     -8037.6715     -8115.9688     -8115.9688      303.0184       303.0184       24090.025      24090.025      251.91551      251.91551    
     73000  -8045.0796     -8045.0796     -8119.2912     -8119.2912      287.20656      287.20656      24091.03       24091.03      -538.51094     -538.51094    
Loop time of 113.248 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.458 hours/ns, 8.830 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.66     | 112.66     | 112.66     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083153   | 0.083153   | 0.083153   |   0.0 |  0.07
Output  | 0.00021592 | 0.00021592 | 0.00021592 |   0.0 |  0.00
Modify  | 0.44558    | 0.44558    | 0.44558    |   0.0 |  0.39
Other   |            | 0.06243    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116234 ave      116234 max      116234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116234
Ave neighs/atom = 58.117
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.325210548441, Press = 1.2930896790951
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -8045.0796     -8045.0796     -8119.2912     -8119.2912      287.20656      287.20656      24091.03       24091.03      -538.51094     -538.51094    
     74000  -8040.2567     -8040.2567     -8117.9265     -8117.9265      300.59013      300.59013      24081.923      24081.923      604.06952      604.06952    
Loop time of 113.377 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.494 hours/ns, 8.820 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.78     | 112.78     | 112.78     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083075   | 0.083075   | 0.083075   |   0.0 |  0.07
Output  | 0.00021159 | 0.00021159 | 0.00021159 |   0.0 |  0.00
Modify  | 0.44789    | 0.44789    | 0.44789    |   0.0 |  0.40
Other   |            | 0.06229    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116202 ave      116202 max      116202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116202
Ave neighs/atom = 58.101
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.351173767181, Press = 2.57246930599331
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -8040.2567     -8040.2567     -8117.9265     -8117.9265      300.59013      300.59013      24081.923      24081.923      604.06952      604.06952    
     75000  -8044.9577     -8044.9577     -8120.2838     -8120.2838      291.51973      291.51973      24085.219      24085.219     -80.461583     -80.461583    
Loop time of 113.373 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.493 hours/ns, 8.820 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.79     | 112.79     | 112.79     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083117   | 0.083117   | 0.083117   |   0.0 |  0.07
Output  | 0.00023432 | 0.00023432 | 0.00023432 |   0.0 |  0.00
Modify  | 0.44297    | 0.44297    | 0.44297    |   0.0 |  0.39
Other   |            | 0.06093    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116194 ave      116194 max      116194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116194
Ave neighs/atom = 58.097
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.358997402949, Press = 1.73077940415523
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -8044.9577     -8044.9577     -8120.2838     -8120.2838      291.51973      291.51973      24085.219      24085.219     -80.461583     -80.461583    
     76000  -8043.388      -8043.388      -8119.1353     -8119.1353      293.15019      293.15019      24075.455      24075.455      870.1687       870.1687     
Loop time of 113.431 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.509 hours/ns, 8.816 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.84     | 112.84     | 112.84     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083727   | 0.083727   | 0.083727   |   0.0 |  0.07
Output  | 0.00016946 | 0.00016946 | 0.00016946 |   0.0 |  0.00
Modify  | 0.44558    | 0.44558    | 0.44558    |   0.0 |  0.39
Other   |            | 0.06122    |            |       |  0.05

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

Total # of neighbors = 116176
Ave neighs/atom = 58.088
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.349062480278, Press = 2.09161742430296
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -8043.388      -8043.388      -8119.1353     -8119.1353      293.15019      293.15019      24075.455      24075.455      870.1687       870.1687     
     77000  -8041.3638     -8041.3638     -8119.1762     -8119.1762      301.14211      301.14211      24110.285      24110.285     -1720.9923     -1720.9923    
Loop time of 113.469 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.519 hours/ns, 8.813 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.87     | 112.87     | 112.87     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083497   | 0.083497   | 0.083497   |   0.0 |  0.07
Output  | 0.00023383 | 0.00023383 | 0.00023383 |   0.0 |  0.00
Modify  | 0.44927    | 0.44927    | 0.44927    |   0.0 |  0.40
Other   |            | 0.06191    |            |       |  0.05

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

Total # of neighbors = 116164
Ave neighs/atom = 58.082
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.338370357886, Press = 1.77440993657167
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -8041.3638     -8041.3638     -8119.1762     -8119.1762      301.14211      301.14211      24110.285      24110.285     -1720.9923     -1720.9923    
     78000  -8045.0654     -8045.0654     -8120.059      -8120.059       290.23329      290.23329      24039.427      24039.427      3464.5792      3464.5792    
Loop time of 113.453 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.515 hours/ns, 8.814 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.86     | 112.86     | 112.86     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084791   | 0.084791   | 0.084791   |   0.0 |  0.07
Output  | 0.00017314 | 0.00017314 | 0.00017314 |   0.0 |  0.00
Modify  | 0.44874    | 0.44874    | 0.44874    |   0.0 |  0.40
Other   |            | 0.06216    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116152 ave      116152 max      116152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116152
Ave neighs/atom = 58.076
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.352739875683, Press = 1.83278628226503
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -8045.0654     -8045.0654     -8120.059      -8120.059       290.23329      290.23329      24039.427      24039.427      3464.5792      3464.5792    
     79000  -8041.7093     -8041.7093     -8118.6607     -8118.6607      297.81         297.81         24126.237      24126.237     -2970.0983     -2970.0983    
Loop time of 110.329 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.75     | 109.75     | 109.75     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081899   | 0.081899   | 0.081899   |   0.0 |  0.07
Output  | 0.00016993 | 0.00016993 | 0.00016993 |   0.0 |  0.00
Modify  | 0.43181    | 0.43181    | 0.43181    |   0.0 |  0.39
Other   |            | 0.06074    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2947 ave        2947 max        2947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116200 ave      116200 max      116200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116200
Ave neighs/atom = 58.1
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.384973475244, Press = 2.20318043662206
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -8041.7093     -8041.7093     -8118.6607     -8118.6607      297.81         297.81         24126.237      24126.237     -2970.0983     -2970.0983    
     80000  -8043.2576     -8043.2576     -8119.0471     -8119.0471      293.31307      293.31307      24058.911      24058.911      2056.9505      2056.9505    
Loop time of 97.0898 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.890 ns/day, 26.969 hours/ns, 10.300 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.6       | 96.6       | 96.6       |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073263   | 0.073263   | 0.073263   |   0.0 |  0.08
Output  | 0.00017024 | 0.00017024 | 0.00017024 |   0.0 |  0.00
Modify  | 0.36065    | 0.36065    | 0.36065    |   0.0 |  0.37
Other   |            | 0.05542    |            |       |  0.06

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

Total # of neighbors = 116174
Ave neighs/atom = 58.087
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.392653119122, Press = 1.47073035107366
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -8043.2576     -8043.2576     -8119.0471     -8119.0471      293.31307      293.31307      24058.911      24058.911      2056.9505      2056.9505    
     81000  -8046.9206     -8046.9206     -8120.6393     -8120.6393      285.29908      285.29908      24094.18       24094.18      -940.9789      -940.9789     
Loop time of 96.4098 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.780 hours/ns, 10.372 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.924     | 95.924     | 95.924     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072181   | 0.072181   | 0.072181   |   0.0 |  0.07
Output  | 0.00020016 | 0.00020016 | 0.00020016 |   0.0 |  0.00
Modify  | 0.35779    | 0.35779    | 0.35779    |   0.0 |  0.37
Other   |            | 0.05542    |            |       |  0.06

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

Total # of neighbors = 116210
Ave neighs/atom = 58.105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.387250118776, Press = 2.20926436828071
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -8046.9206     -8046.9206     -8120.6393     -8120.6393      285.29908      285.29908      24094.18       24094.18      -940.9789      -940.9789     
     82000  -8042.9601     -8042.9601     -8120.2356     -8120.2356      299.06412      299.06412      24082.049      24082.049      289.34063      289.34063    
Loop time of 96.668 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.852 hours/ns, 10.345 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.182     | 96.182     | 96.182     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072357   | 0.072357   | 0.072357   |   0.0 |  0.07
Output  | 0.00017083 | 0.00017083 | 0.00017083 |   0.0 |  0.00
Modify  | 0.35815    | 0.35815    | 0.35815    |   0.0 |  0.37
Other   |            | 0.05531    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116204 ave      116204 max      116204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116204
Ave neighs/atom = 58.102
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.362203590088, Press = 1.60277019077737
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -8042.9601     -8042.9601     -8120.2356     -8120.2356      299.06412      299.06412      24082.049      24082.049      289.34063      289.34063    
     83000  -8044.552      -8044.552      -8121.393      -8121.393       297.38228      297.38228      24088.625      24088.625     -509.14245     -509.14245    
Loop time of 110.634 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.06     | 110.06     | 110.06     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080001   | 0.080001   | 0.080001   |   0.0 |  0.07
Output  | 0.00016928 | 0.00016928 | 0.00016928 |   0.0 |  0.00
Modify  | 0.43214    | 0.43214    | 0.43214    |   0.0 |  0.39
Other   |            | 0.06182    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116176 ave      116176 max      116176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116176
Ave neighs/atom = 58.088
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.363912874749, Press = 1.84574827944329
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -8044.552      -8044.552      -8121.393      -8121.393       297.38228      297.38228      24088.625      24088.625     -509.14245     -509.14245    
     84000  -8042.341      -8042.341      -8118.3724     -8118.3724      294.24953      294.24953      24088.837      24088.837     -46.626422     -46.626422    
Loop time of 111.418 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.775 ns/day, 30.949 hours/ns, 8.975 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.84     | 110.84     | 110.84     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081497   | 0.081497   | 0.081497   |   0.0 |  0.07
Output  | 0.00017248 | 0.00017248 | 0.00017248 |   0.0 |  0.00
Modify  | 0.43482    | 0.43482    | 0.43482    |   0.0 |  0.39
Other   |            | 0.06307    |            |       |  0.06

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

Total # of neighbors = 116178
Ave neighs/atom = 58.089
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.344427368656, Press = 1.67279100075726
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -8042.341      -8042.341      -8118.3724     -8118.3724      294.24953      294.24953      24088.837      24088.837     -46.626422     -46.626422    
     85000  -8046.7169     -8046.7169     -8121.6272     -8121.6272      289.91058      289.91058      24080.925      24080.925      3.0405092      3.0405092    
Loop time of 113.799 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.759 ns/day, 31.611 hours/ns, 8.787 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.2      | 113.2      | 113.2      |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084907   | 0.084907   | 0.084907   |   0.0 |  0.07
Output  | 0.00016655 | 0.00016655 | 0.00016655 |   0.0 |  0.00
Modify  | 0.45493    | 0.45493    | 0.45493    |   0.0 |  0.40
Other   |            | 0.0639     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116186 ave      116186 max      116186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116186
Ave neighs/atom = 58.093
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.329583563078, Press = 1.48277517684734
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -8046.7169     -8046.7169     -8121.6272     -8121.6272      289.91058      289.91058      24080.925      24080.925      3.0405092      3.0405092    
     86000  -8042.1075     -8042.1075     -8118.0135     -8118.0135      293.76409      293.76409      24084.568      24084.568      331.98302      331.98302    
Loop time of 113.349 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.486 hours/ns, 8.822 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.76     | 112.76     | 112.76     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082799   | 0.082799   | 0.082799   |   0.0 |  0.07
Output  | 0.00017004 | 0.00017004 | 0.00017004 |   0.0 |  0.00
Modify  | 0.44597    | 0.44597    | 0.44597    |   0.0 |  0.39
Other   |            | 0.06231    |            |       |  0.05

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

Total # of neighbors = 116194
Ave neighs/atom = 58.097
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.314631621125, Press = 1.99552947137974
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -8042.1075     -8042.1075     -8118.0135     -8118.0135      293.76409      293.76409      24084.568      24084.568      331.98302      331.98302    
     87000  -8046.9848     -8046.9848     -8120.4802     -8120.4802      284.43484      284.43484      24096.305      24096.305     -1024.5772     -1024.5772    
Loop time of 113.494 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.526 hours/ns, 8.811 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.9      | 112.9      | 112.9      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082823   | 0.082823   | 0.082823   |   0.0 |  0.07
Output  | 0.00020717 | 0.00020717 | 0.00020717 |   0.0 |  0.00
Modify  | 0.4483     | 0.4483     | 0.4483     |   0.0 |  0.40
Other   |            | 0.06278    |            |       |  0.06

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

Total # of neighbors = 116192
Ave neighs/atom = 58.096
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.298025029989, Press = 1.14871634694952
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -8046.9848     -8046.9848     -8120.4802     -8120.4802      284.43484      284.43484      24096.305      24096.305     -1024.5772     -1024.5772    
     88000  -8042.6204     -8042.6204     -8118.4577     -8118.4577      293.49844      293.49844      24061.009      24061.009      2057.5998      2057.5998    
Loop time of 112.983 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.384 hours/ns, 8.851 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.39     | 112.39     | 112.39     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083029   | 0.083029   | 0.083029   |   0.0 |  0.07
Output  | 0.00017036 | 0.00017036 | 0.00017036 |   0.0 |  0.00
Modify  | 0.44314    | 0.44314    | 0.44314    |   0.0 |  0.39
Other   |            | 0.06244    |            |       |  0.06

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

Total # of neighbors = 116168
Ave neighs/atom = 58.084
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.278449429877, Press = 1.96940367176936
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -8042.6204     -8042.6204     -8118.4577     -8118.4577      293.49844      293.49844      24061.009      24061.009      2057.5998      2057.5998    
     89000  -8044.4699     -8044.4699     -8119.4553     -8119.4553      290.20129      290.20129      24131.132      24131.132     -3368.8965     -3368.8965    
Loop time of 111.987 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.772 ns/day, 31.107 hours/ns, 8.930 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.4      | 111.4      | 111.4      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082031   | 0.082031   | 0.082031   |   0.0 |  0.07
Output  | 0.00016802 | 0.00016802 | 0.00016802 |   0.0 |  0.00
Modify  | 0.4388     | 0.4388     | 0.4388     |   0.0 |  0.39
Other   |            | 0.06256    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116212 ave      116212 max      116212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116212
Ave neighs/atom = 58.106
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.284301853977, Press = 1.34418062136134
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -8044.4699     -8044.4699     -8119.4553     -8119.4553      290.20129      290.20129      24131.132      24131.132     -3368.8965     -3368.8965    
     90000  -8044.0275     -8044.0275     -8118.9541     -8118.9541      289.97339      289.97339      24041.111      24041.111      3579.9366      3579.9366    
Loop time of 113.481 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.522 hours/ns, 8.812 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.89     | 112.89     | 112.89     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083192   | 0.083192   | 0.083192   |   0.0 |  0.07
Output  | 0.00016786 | 0.00016786 | 0.00016786 |   0.0 |  0.00
Modify  | 0.44537    | 0.44537    | 0.44537    |   0.0 |  0.39
Other   |            | 0.06207    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2946 ave        2946 max        2946 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116190 ave      116190 max      116190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116190
Ave neighs/atom = 58.095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.278734120493, Press = 1.61631903921457
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     90000  -8044.0275     -8044.0275     -8118.9541     -8118.9541      289.97339      289.97339      24041.111      24041.111      3579.9366      3579.9366    
     91000  -8043.3076     -8043.3076     -8119.143      -8119.143       293.49078      293.49078      24103.832      24103.832     -1254.8001     -1254.8001    
Loop time of 113.1 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.417 hours/ns, 8.842 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.51     | 112.51     | 112.51     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082153   | 0.082153   | 0.082153   |   0.0 |  0.07
Output  | 0.0002334  | 0.0002334  | 0.0002334  |   0.0 |  0.00
Modify  | 0.44133    | 0.44133    | 0.44133    |   0.0 |  0.39
Other   |            | 0.06237    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116240 ave      116240 max      116240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116240
Ave neighs/atom = 58.12
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.295080837696, Press = 1.46622906198301
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     91000  -8043.3076     -8043.3076     -8119.143      -8119.143       293.49078      293.49078      24103.832      24103.832     -1254.8001     -1254.8001    
     92000  -8048.1472     -8048.1472     -8121.6586     -8121.6586      284.49635      284.49635      24067.498      24067.498      1065.4045      1065.4045    
Loop time of 112.796 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.332 hours/ns, 8.866 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.2      | 112.2      | 112.2      |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083156   | 0.083156   | 0.083156   |   0.0 |  0.07
Output  | 0.00023487 | 0.00023487 | 0.00023487 |   0.0 |  0.00
Modify  | 0.44689    | 0.44689    | 0.44689    |   0.0 |  0.40
Other   |            | 0.06235    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116208 ave      116208 max      116208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116208
Ave neighs/atom = 58.104
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.263296054455, Press = 1.43643818840981
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     92000  -8048.1472     -8048.1472     -8121.6586     -8121.6586      284.49635      284.49635      24067.498      24067.498      1065.4045      1065.4045    
     93000  -8043.6828     -8043.6828     -8119.5366     -8119.5366      293.56223      293.56223      24099.187      24099.187     -965.975       -965.975      
Loop time of 113.056 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.404 hours/ns, 8.845 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.47     | 112.47     | 112.47     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082554   | 0.082554   | 0.082554   |   0.0 |  0.07
Output  | 0.00021214 | 0.00021214 | 0.00021214 |   0.0 |  0.00
Modify  | 0.44269    | 0.44269    | 0.44269    |   0.0 |  0.39
Other   |            | 0.06228    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116220 ave      116220 max      116220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116220
Ave neighs/atom = 58.11
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.2580173832, Press = 1.63638937552128
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -8043.6828     -8043.6828     -8119.5366     -8119.5366      293.56223      293.56223      24099.187      24099.187     -965.975       -965.975      
     94000  -8042.4893     -8042.4893     -8118.911      -8118.911       295.76         295.76         24073.405      24073.405      1057.9866      1057.9866    
Loop time of 112.967 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.380 hours/ns, 8.852 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.38     | 112.38     | 112.38     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083133   | 0.083133   | 0.083133   |   0.0 |  0.07
Output  | 0.00028014 | 0.00028014 | 0.00028014 |   0.0 |  0.00
Modify  | 0.44231    | 0.44231    | 0.44231    |   0.0 |  0.39
Other   |            | 0.06196    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116172 ave      116172 max      116172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116172
Ave neighs/atom = 58.086
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.256568512291, Press = 0.805144863229671
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -8042.4893     -8042.4893     -8118.911      -8118.911       295.76         295.76         24073.405      24073.405      1057.9866      1057.9866    
     95000  -8042.5069     -8042.5069     -8117.6556     -8117.6556      290.83312      290.83312      24090.549      24090.549     -59.072383     -59.072383    
Loop time of 113.242 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.456 hours/ns, 8.831 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.65     | 112.65     | 112.65     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082588   | 0.082588   | 0.082588   |   0.0 |  0.07
Output  | 0.00023443 | 0.00023443 | 0.00023443 |   0.0 |  0.00
Modify  | 0.44734    | 0.44734    | 0.44734    |   0.0 |  0.40
Other   |            | 0.06328    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116222 ave      116222 max      116222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116222
Ave neighs/atom = 58.111
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.288166371015, Press = 2.32810808413703
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -8042.5069     -8042.5069     -8117.6556     -8117.6556      290.83312      290.83312      24090.549      24090.549     -59.072383     -59.072383    
     96000  -8047.8263     -8047.8263     -8121.6751     -8121.6751      285.80234      285.80234      24085.406      24085.406     -272.55978     -272.55978    
Loop time of 111.532 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.95     | 110.95     | 110.95     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082171   | 0.082171   | 0.082171   |   0.0 |  0.07
Output  | 0.00020555 | 0.00020555 | 0.00020555 |   0.0 |  0.00
Modify  | 0.4396     | 0.4396     | 0.4396     |   0.0 |  0.39
Other   |            | 0.06215    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2947 ave        2947 max        2947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116246 ave      116246 max      116246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116246
Ave neighs/atom = 58.123
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.270630371316, Press = 0.728740616039884
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -8047.8263     -8047.8263     -8121.6751     -8121.6751      285.80234      285.80234      24085.406      24085.406     -272.55978     -272.55978    
     97000  -8042.6642     -8042.6642     -8118.2602     -8118.2602      292.56417      292.56417      24078.926      24078.926      738.69461      738.69461    
Loop time of 110.961 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.38     | 110.38     | 110.38     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081048   | 0.081048   | 0.081048   |   0.0 |  0.07
Output  | 0.00017027 | 0.00017027 | 0.00017027 |   0.0 |  0.00
Modify  | 0.43403    | 0.43403    | 0.43403    |   0.0 |  0.39
Other   |            | 0.06118    |            |       |  0.06

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

Total # of neighbors = 116162
Ave neighs/atom = 58.081
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.255817229215, Press = 2.09255561270839
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     97000  -8042.6642     -8042.6642     -8118.2602     -8118.2602      292.56417      292.56417      24078.926      24078.926      738.69461      738.69461    
     98000  -8039.6054     -8039.6054     -8118.9532     -8118.9532      307.08408      307.08408      24102.15       24102.15      -977.25122     -977.25122    
Loop time of 113.234 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.454 hours/ns, 8.831 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.67     | 112.67     | 112.67     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079958   | 0.079958   | 0.079958   |   0.0 |  0.07
Output  | 0.00016726 | 0.00016726 | 0.00016726 |   0.0 |  0.00
Modify  | 0.42413    | 0.42413    | 0.42413    |   0.0 |  0.37
Other   |            | 0.06103    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116246 ave      116246 max      116246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116246
Ave neighs/atom = 58.123
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.267431002518, Press = 1.02770455183285
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -8039.6054     -8039.6054     -8118.9532     -8118.9532      307.08408      307.08408      24102.15       24102.15      -977.25122     -977.25122    
     99000  -8044.5091     -8044.5091     -8120.3343     -8120.3343      293.45156      293.45156      24078.693      24078.693      491.31563      491.31563    
Loop time of 112.967 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.380 hours/ns, 8.852 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.38     | 112.38     | 112.38     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082936   | 0.082936   | 0.082936   |   0.0 |  0.07
Output  | 0.00016821 | 0.00016821 | 0.00016821 |   0.0 |  0.00
Modify  | 0.44425    | 0.44425    | 0.44425    |   0.0 |  0.39
Other   |            | 0.06313    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116196 ave      116196 max      116196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116196
Ave neighs/atom = 58.098
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.28234793601, Press = 1.58470516953471
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -8044.5091     -8044.5091     -8120.3343     -8120.3343      293.45156      293.45156      24078.693      24078.693      491.31563      491.31563    
    100000  -8046.3651     -8046.3651     -8120.3481     -8120.3481      286.32167      286.32167      24091.191      24091.191     -545.10363     -545.10363    
Loop time of 113.148 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.430 hours/ns, 8.838 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.56     | 112.56     | 112.56     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083323   | 0.083323   | 0.083323   |   0.0 |  0.07
Output  | 0.0002077  | 0.0002077  | 0.0002077  |   0.0 |  0.00
Modify  | 0.44609    | 0.44609    | 0.44609    |   0.0 |  0.39
Other   |            | 0.06347    |            |       |  0.06

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

Total # of neighbors = 116208
Ave neighs/atom = 58.104
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.286398358874, Press = 1.18874447002312
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    100000  -8046.3651     -8046.3651     -8120.3481     -8120.3481      286.32167      286.32167      24091.191      24091.191     -545.10363     -545.10363    
    101000  -8044.3382     -8044.3382     -8119.1633     -8119.1633      289.5808       289.5808       24073.48       24073.48       933.13456      933.13456    
Loop time of 113.411 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.503 hours/ns, 8.817 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.82     | 112.82     | 112.82     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083254   | 0.083254   | 0.083254   |   0.0 |  0.07
Output  | 0.00028025 | 0.00028025 | 0.00028025 |   0.0 |  0.00
Modify  | 0.44525    | 0.44525    | 0.44525    |   0.0 |  0.39
Other   |            | 0.0627     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116208 ave      116208 max      116208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116208
Ave neighs/atom = 58.104
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.252156865725, Press = 1.290543695717
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -8044.3382     -8044.3382     -8119.1633     -8119.1633      289.5808       289.5808       24073.48       24073.48       933.13456      933.13456    
    102000  -8044.8982     -8044.8982     -8119.4048     -8119.4048      288.34839      288.34839      24116.318      24116.318     -2330.1411     -2330.1411    
Loop time of 113.357 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.488 hours/ns, 8.822 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.76     | 112.76     | 112.76     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083297   | 0.083297   | 0.083297   |   0.0 |  0.07
Output  | 0.00017313 | 0.00017313 | 0.00017313 |   0.0 |  0.00
Modify  | 0.44576    | 0.44576    | 0.44576    |   0.0 |  0.39
Other   |            | 0.06334    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116202 ave      116202 max      116202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116202
Ave neighs/atom = 58.101
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.249685919782, Press = 1.25393631652644
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    102000  -8044.8982     -8044.8982     -8119.4048     -8119.4048      288.34839      288.34839      24116.318      24116.318     -2330.1411     -2330.1411    
    103000  -8044.3576     -8044.3576     -8120.0065     -8120.0065      292.7692       292.7692       24052.973      24052.973      2644.7579      2644.7579    
Loop time of 113.537 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.538 hours/ns, 8.808 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.94     | 112.94     | 112.94     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083492   | 0.083492   | 0.083492   |   0.0 |  0.07
Output  | 0.00023167 | 0.00023167 | 0.00023167 |   0.0 |  0.00
Modify  | 0.44848    | 0.44848    | 0.44848    |   0.0 |  0.40
Other   |            | 0.06335    |            |       |  0.06

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

Total # of neighbors = 116172
Ave neighs/atom = 58.086
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.227430635059, Press = 1.16291881602203
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    103000  -8044.3576     -8044.3576     -8120.0065     -8120.0065      292.7692       292.7692       24052.973      24052.973      2644.7579      2644.7579    
    104000  -8046.3846     -8046.3846     -8121.3996     -8121.3996      290.31589      290.31589      24115.978      24115.978     -2446.3183     -2446.3183    
Loop time of 113.615 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.560 hours/ns, 8.802 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.02     | 113.02     | 113.02     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083716   | 0.083716   | 0.083716   |   0.0 |  0.07
Output  | 0.0002173  | 0.0002173  | 0.0002173  |   0.0 |  0.00
Modify  | 0.44975    | 0.44975    | 0.44975    |   0.0 |  0.40
Other   |            | 0.0642     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116218 ave      116218 max      116218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116218
Ave neighs/atom = 58.109
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.218302660317, Press = 1.41165052293438
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    104000  -8046.3846     -8046.3846     -8121.3996     -8121.3996      290.31589      290.31589      24115.978      24115.978     -2446.3183     -2446.3183    
    105000  -8043.4699     -8043.4699     -8119.8859     -8119.8859      295.7376       295.7376       24056.338      24056.338      2316.9997      2316.9997    
Loop time of 113.522 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.534 hours/ns, 8.809 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.93     | 112.93     | 112.93     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083406   | 0.083406   | 0.083406   |   0.0 |  0.07
Output  | 0.0002092  | 0.0002092  | 0.0002092  |   0.0 |  0.00
Modify  | 0.44597    | 0.44597    | 0.44597    |   0.0 |  0.39
Other   |            | 0.06351    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2949 ave        2949 max        2949 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116170 ave      116170 max      116170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116170
Ave neighs/atom = 58.085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.188326376682, Press = 0.916088660656584
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    105000  -8043.4699     -8043.4699     -8119.8859     -8119.8859      295.7376       295.7376       24056.338      24056.338      2316.9997      2316.9997    
    106000  -8046.9532     -8046.9532     -8121.5265     -8121.5265      288.60618      288.60618      24093.471      24093.471     -832.88312     -832.88312    
Loop time of 113.446 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.513 hours/ns, 8.815 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.85     | 112.85     | 112.85     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08376    | 0.08376    | 0.08376    |   0.0 |  0.07
Output  | 0.0001703  | 0.0001703  | 0.0001703  |   0.0 |  0.00
Modify  | 0.44488    | 0.44488    | 0.44488    |   0.0 |  0.39
Other   |            | 0.06352    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116220 ave      116220 max      116220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116220
Ave neighs/atom = 58.11
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.173347541418, Press = 1.54084373089048
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    106000  -8046.9532     -8046.9532     -8121.5265     -8121.5265      288.60618      288.60618      24093.471      24093.471     -832.88312     -832.88312    
    107000  -8042.037      -8042.037      -8118.1264     -8118.1264      294.47367      294.47367      24086.839      24086.839      141.44297      141.44297    
Loop time of 113.523 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.534 hours/ns, 8.809 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.93     | 112.93     | 112.93     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082908   | 0.082908   | 0.082908   |   0.0 |  0.07
Output  | 0.00017026 | 0.00017026 | 0.00017026 |   0.0 |  0.00
Modify  | 0.44776    | 0.44776    | 0.44776    |   0.0 |  0.39
Other   |            | 0.06422    |            |       |  0.06

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

Total # of neighbors = 116166
Ave neighs/atom = 58.083
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.157307473979, Press = 1.07720122848786
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    107000  -8042.037      -8042.037      -8118.1264     -8118.1264      294.47367      294.47367      24086.839      24086.839      141.44297      141.44297    
    108000  -8040.9359     -8040.9359     -8119.5942     -8119.5942      304.4158       304.4158       24088.389      24088.389      17.538124      17.538124    
Loop time of 111.736 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.773 ns/day, 31.038 hours/ns, 8.950 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.15     | 111.15     | 111.15     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082449   | 0.082449   | 0.082449   |   0.0 |  0.07
Output  | 0.00016544 | 0.00016544 | 0.00016544 |   0.0 |  0.00
Modify  | 0.43717    | 0.43717    | 0.43717    |   0.0 |  0.39
Other   |            | 0.06271    |            |       |  0.06

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

Total # of neighbors = 116188
Ave neighs/atom = 58.094
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.157893619827, Press = 1.24347217126999
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    108000  -8040.9359     -8040.9359     -8119.5942     -8119.5942      304.4158       304.4158       24088.389      24088.389      17.538124      17.538124    
    109000  -8043.9986     -8043.9986     -8117.821      -8117.821       285.70037      285.70037      24094.02       24094.02      -330.05941     -330.05941    
Loop time of 111.979 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.772 ns/day, 31.105 hours/ns, 8.930 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.4      | 111.4      | 111.4      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081959   | 0.081959   | 0.081959   |   0.0 |  0.07
Output  | 0.00017043 | 0.00017043 | 0.00017043 |   0.0 |  0.00
Modify  | 0.43932    | 0.43932    | 0.43932    |   0.0 |  0.39
Other   |            | 0.06242    |            |       |  0.06

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

Total # of neighbors = 116174
Ave neighs/atom = 58.087
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.183883666129, Press = 1.16725188354083
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    109000  -8043.9986     -8043.9986     -8117.821      -8117.821       285.70037      285.70037      24094.02       24094.02      -330.05941     -330.05941    
    110000  -8042.6383     -8042.6383     -8118.3091     -8118.3091      292.85404      292.85404      24077.703      24077.703      1000.0444      1000.0444    
Loop time of 108.541 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.796 ns/day, 30.150 hours/ns, 9.213 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 107.98     | 107.98     | 107.98     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079172   | 0.079172   | 0.079172   |   0.0 |  0.07
Output  | 0.00020759 | 0.00020759 | 0.00020759 |   0.0 |  0.00
Modify  | 0.42065    | 0.42065    | 0.42065    |   0.0 |  0.39
Other   |            | 0.06077    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116196 ave      116196 max      116196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116196
Ave neighs/atom = 58.098
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.186927457151, Press = 1.07025074242845
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    110000  -8042.6383     -8042.6383     -8118.3091     -8118.3091      292.85404      292.85404      24077.703      24077.703      1000.0444      1000.0444    
    111000  -8041.774      -8041.774      -8118.4623     -8118.4623      296.79158      296.79158      24104.572      24104.572     -1084.0386     -1084.0386    
Loop time of 113.164 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.434 hours/ns, 8.837 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.57     | 112.57     | 112.57     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082487   | 0.082487   | 0.082487   |   0.0 |  0.07
Output  | 0.00020644 | 0.00020644 | 0.00020644 |   0.0 |  0.00
Modify  | 0.44608    | 0.44608    | 0.44608    |   0.0 |  0.39
Other   |            | 0.06158    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2946 ave        2946 max        2946 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116198 ave      116198 max      116198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116198
Ave neighs/atom = 58.099
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.214612570999, Press = 1.16961683251319
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    111000  -8041.774      -8041.774      -8118.4623     -8118.4623      296.79158      296.79158      24104.572      24104.572     -1084.0386     -1084.0386    
    112000  -8044.9015     -8044.9015     -8121.4899     -8121.4899      296.40476      296.40476      24064.713      24064.713      1504.9347      1504.9347    
Loop time of 112.974 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.765 ns/day, 31.382 hours/ns, 8.852 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.38     | 112.38     | 112.38     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081524   | 0.081524   | 0.081524   |   0.0 |  0.07
Output  | 0.00016796 | 0.00016796 | 0.00016796 |   0.0 |  0.00
Modify  | 0.44465    | 0.44465    | 0.44465    |   0.0 |  0.39
Other   |            | 0.06239    |            |       |  0.06

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

Total # of neighbors = 116174
Ave neighs/atom = 58.087
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.22578114961, Press = 0.838158092378294
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    112000  -8044.9015     -8044.9015     -8121.4899     -8121.4899      296.40476      296.40476      24064.713      24064.713      1504.9347      1504.9347    
    113000  -8045.8239     -8045.8239     -8119.5395     -8119.5395      285.28687      285.28687      24118.009      24118.009     -2471.3166     -2471.3166    
Loop time of 113.183 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.440 hours/ns, 8.835 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.59     | 112.59     | 112.59     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081985   | 0.081985   | 0.081985   |   0.0 |  0.07
Output  | 0.0001714  | 0.0001714  | 0.0001714  |   0.0 |  0.00
Modify  | 0.4455     | 0.4455     | 0.4455     |   0.0 |  0.39
Other   |            | 0.0626     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116202 ave      116202 max      116202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116202
Ave neighs/atom = 58.101
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.237758020542, Press = 1.47036217360692
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    113000  -8045.8239     -8045.8239     -8119.5395     -8119.5395      285.28687      285.28687      24118.009      24118.009     -2471.3166     -2471.3166    
    114000  -8045.1625     -8045.1625     -8119.6657     -8119.6657      288.33529      288.33529      24062.768      24062.768      1849.9518      1849.9518    
Loop time of 113.106 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.418 hours/ns, 8.841 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.51     | 112.51     | 112.51     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081633   | 0.081633   | 0.081633   |   0.0 |  0.07
Output  | 0.00019902 | 0.00019902 | 0.00019902 |   0.0 |  0.00
Modify  | 0.44674    | 0.44674    | 0.44674    |   0.0 |  0.39
Other   |            | 0.06278    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116148 ave      116148 max      116148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116148
Ave neighs/atom = 58.074
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.217524922599, Press = 0.571071745302828
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    114000  -8045.1625     -8045.1625     -8119.6657     -8119.6657      288.33529      288.33529      24062.768      24062.768      1849.9518      1849.9518    
    115000  -8044.0636     -8044.0636     -8119.1582     -8119.1582      290.62398      290.62398      24097.663      24097.663     -746.6303      -746.6303     
Loop time of 113.62 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.561 hours/ns, 8.801 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.03     | 113.03     | 113.03     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082543   | 0.082543   | 0.082543   |   0.0 |  0.07
Output  | 0.00021188 | 0.00021188 | 0.00021188 |   0.0 |  0.00
Modify  | 0.4463     | 0.4463     | 0.4463     |   0.0 |  0.39
Other   |            | 0.06245    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116214 ave      116214 max      116214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116214
Ave neighs/atom = 58.107
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.207259573729, Press = 1.33388663996857
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    115000  -8044.0636     -8044.0636     -8119.1582     -8119.1582      290.62398      290.62398      24097.663      24097.663     -746.6303      -746.6303     
    116000  -8043.6802     -8043.6802     -8119.2622     -8119.2622      292.51021      292.51021      24081.003      24081.003      585.69254      585.69254    
Loop time of 113.623 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.562 hours/ns, 8.801 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.03     | 113.03     | 113.03     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083184   | 0.083184   | 0.083184   |   0.0 |  0.07
Output  | 0.00016962 | 0.00016962 | 0.00016962 |   0.0 |  0.00
Modify  | 0.44607    | 0.44607    | 0.44607    |   0.0 |  0.39
Other   |            | 0.06326    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116238 ave      116238 max      116238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116238
Ave neighs/atom = 58.119
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.20440387851, Press = 0.89392139077117
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    116000  -8043.6802     -8043.6802     -8119.2622     -8119.2622      292.51021      292.51021      24081.003      24081.003      585.69254      585.69254    
    117000  -8044.349      -8044.349      -8118.7191     -8118.7191      287.82016      287.82016      24089.11       24089.11      -135.5075      -135.5075     
Loop time of 113.571 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.548 hours/ns, 8.805 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.98     | 112.98     | 112.98     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082363   | 0.082363   | 0.082363   |   0.0 |  0.07
Output  | 0.00016704 | 0.00016704 | 0.00016704 |   0.0 |  0.00
Modify  | 0.4453     | 0.4453     | 0.4453     |   0.0 |  0.39
Other   |            | 0.06241    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2946 ave        2946 max        2946 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116188 ave      116188 max      116188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116188
Ave neighs/atom = 58.094
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.229816671248, Press = 1.09443699892544
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    117000  -8044.349      -8044.349      -8118.7191     -8118.7191      287.82016      287.82016      24089.11       24089.11      -135.5075      -135.5075     
    118000  -8042.0282     -8042.0282     -8119.9241     -8119.9241      301.46507      301.46507      24093.564      24093.564     -401.74598     -401.74598    
Loop time of 107.068 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.51     | 106.51     | 106.51     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07895    | 0.07895    | 0.07895    |   0.0 |  0.07
Output  | 0.00016947 | 0.00016947 | 0.00016947 |   0.0 |  0.00
Modify  | 0.41621    | 0.41621    | 0.41621    |   0.0 |  0.39
Other   |            | 0.06009    |            |       |  0.06

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

Total # of neighbors = 116204
Ave neighs/atom = 58.102
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.227568566274, Press = 0.883084475461851
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    118000  -8042.0282     -8042.0282     -8119.9241     -8119.9241      301.46507      301.46507      24093.564      24093.564     -401.74598     -401.74598    
    119000  -8047.4919     -8047.4919     -8121.1586     -8121.1586      285.09801      285.09801      24072.078      24072.078      953.24262      953.24262    
Loop time of 113.198 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.444 hours/ns, 8.834 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.61     | 112.61     | 112.61     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082569   | 0.082569   | 0.082569   |   0.0 |  0.07
Output  | 0.00016797 | 0.00016797 | 0.00016797 |   0.0 |  0.00
Modify  | 0.4472     | 0.4472     | 0.4472     |   0.0 |  0.40
Other   |            | 0.06285    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2945 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116176 ave      116176 max      116176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116176
Ave neighs/atom = 58.088
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.202817703456, Press = 1.1651500921427
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    119000  -8047.4919     -8047.4919     -8121.1586     -8121.1586      285.09801      285.09801      24072.078      24072.078      953.24262      953.24262    
    120000  -8042.9664     -8042.9664     -8118.3972     -8118.3972      291.92518      291.92518      24100.81       24100.81      -831.17336     -831.17336    
Loop time of 113.175 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.437 hours/ns, 8.836 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.58     | 112.58     | 112.58     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083257   | 0.083257   | 0.083257   |   0.0 |  0.07
Output  | 0.00016683 | 0.00016683 | 0.00016683 |   0.0 |  0.00
Modify  | 0.44816    | 0.44816    | 0.44816    |   0.0 |  0.40
Other   |            | 0.06294    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2948 ave        2948 max        2948 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116212 ave      116212 max      116212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116212
Ave neighs/atom = 58.106
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.198808316352, Press = 0.853927627941689
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    120000  -8042.9664     -8042.9664     -8118.3972     -8118.3972      291.92518      291.92518      24100.81       24100.81      -831.17336     -831.17336    
    121000  -8046.2289     -8046.2289     -8121.4153     -8121.4153      290.97937      290.97937      24063.678      24063.678      1597.411       1597.411     
Loop time of 109.436 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.399 hours/ns, 9.138 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.87     | 108.87     | 108.87     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07944    | 0.07944    | 0.07944    |   0.0 |  0.07
Output  | 0.00016928 | 0.00016928 | 0.00016928 |   0.0 |  0.00
Modify  | 0.42466    | 0.42466    | 0.42466    |   0.0 |  0.39
Other   |            | 0.06183    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116190 ave      116190 max      116190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116190
Ave neighs/atom = 58.095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.18062968871, Press = 0.99454133139791
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    121000  -8046.2289     -8046.2289     -8121.4153     -8121.4153      290.97937      290.97937      24063.678      24063.678      1597.411       1597.411     
    122000  -8042.0954     -8042.0954     -8117.0436     -8117.0436      290.05714      290.05714      24121.797      24121.797     -2348.9235     -2348.9235    
Loop time of 113.262 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.462 hours/ns, 8.829 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.67     | 112.67     | 112.67     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08271    | 0.08271    | 0.08271    |   0.0 |  0.07
Output  | 0.00021744 | 0.00021744 | 0.00021744 |   0.0 |  0.00
Modify  | 0.44507    | 0.44507    | 0.44507    |   0.0 |  0.39
Other   |            | 0.06304    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116230 ave      116230 max      116230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116230
Ave neighs/atom = 58.115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.169768547251, Press = 0.953034835614432
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    122000  -8042.0954     -8042.0954     -8117.0436     -8117.0436      290.05714      290.05714      24121.797      24121.797     -2348.9235     -2348.9235    
    123000  -8044.3716     -8044.3716     -8120.5683     -8120.5683      294.88898      294.88898      24049.102      24049.102      2917.3016      2917.3016    
Loop time of 109.763 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.787 ns/day, 30.490 hours/ns, 9.111 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 109.19     | 109.19     | 109.19     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081323   | 0.081323   | 0.081323   |   0.0 |  0.07
Output  | 0.00020141 | 0.00020141 | 0.00020141 |   0.0 |  0.00
Modify  | 0.42885    | 0.42885    | 0.42885    |   0.0 |  0.39
Other   |            | 0.0613     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2949 ave        2949 max        2949 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116196 ave      116196 max      116196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116196
Ave neighs/atom = 58.098
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.167664308417, Press = 0.668924654795568
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    123000  -8044.3716     -8044.3716     -8120.5683     -8120.5683      294.88898      294.88898      24049.102      24049.102      2917.3016      2917.3016    
    124000  -8042.2654     -8042.2654     -8119.9979     -8119.9979      300.8326       300.8326       24119.4        24119.4       -2292.5613     -2292.5613    
Loop time of 96.6619 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.851 hours/ns, 10.345 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.175     | 96.175     | 96.175     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072586   | 0.072586   | 0.072586   |   0.0 |  0.08
Output  | 0.00016666 | 0.00016666 | 0.00016666 |   0.0 |  0.00
Modify  | 0.35888    | 0.35888    | 0.35888    |   0.0 |  0.37
Other   |            | 0.05564    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116234 ave      116234 max      116234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116234
Ave neighs/atom = 58.117
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.165464809146, Press = 1.26900411623357
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    124000  -8042.2654     -8042.2654     -8119.9979     -8119.9979      300.8326       300.8326       24119.4        24119.4       -2292.5613     -2292.5613    
    125000  -8044.859      -8044.859      -8117.8593     -8117.8593      282.51875      282.51875      24067.788      24067.788      1676.2604      1676.2604    
Loop time of 96.7046 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.862 hours/ns, 10.341 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.217     | 96.217     | 96.217     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073069   | 0.073069   | 0.073069   |   0.0 |  0.08
Output  | 0.00016631 | 0.00016631 | 0.00016631 |   0.0 |  0.00
Modify  | 0.35883    | 0.35883    | 0.35883    |   0.0 |  0.37
Other   |            | 0.05593    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2947 ave        2947 max        2947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116152 ave      116152 max      116152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116152
Ave neighs/atom = 58.076
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.185876904033, Press = 0.719598951151177
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    125000  -8044.859      -8044.859      -8117.8593     -8117.8593      282.51875      282.51875      24067.788      24067.788      1676.2604      1676.2604    
    126000  -8041.1483     -8041.1483     -8118.549      -8118.549       299.54877      299.54877      24107.179      24107.179     -1289.9864     -1289.9864    
Loop time of 108.931 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.793 ns/day, 30.259 hours/ns, 9.180 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.36     | 108.36     | 108.36     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08055    | 0.08055    | 0.08055    |   0.0 |  0.07
Output  | 0.00022554 | 0.00022554 | 0.00022554 |   0.0 |  0.00
Modify  | 0.42504    | 0.42504    | 0.42504    |   0.0 |  0.39
Other   |            | 0.06076    |            |       |  0.06

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

Total # of neighbors = 116204
Ave neighs/atom = 58.102
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.186971398691, Press = 1.16466852292464
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    126000  -8041.1483     -8041.1483     -8118.549      -8118.549       299.54877      299.54877      24107.179      24107.179     -1289.9864     -1289.9864    
    127000  -8044.4776     -8044.4776     -8119.8059     -8119.8059      291.52862      291.52862      24077.923      24077.923      676.45435      676.45435    
Loop time of 113.729 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.591 hours/ns, 8.793 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.15     | 113.15     | 113.15     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081026   | 0.081026   | 0.081026   |   0.0 |  0.07
Output  | 0.00025597 | 0.00025597 | 0.00025597 |   0.0 |  0.00
Modify  | 0.43557    | 0.43557    | 0.43557    |   0.0 |  0.38
Other   |            | 0.06203    |            |       |  0.05

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2942 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116190 ave      116190 max      116190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116190
Ave neighs/atom = 58.095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.195202441964, Press = 0.550038146612975
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    127000  -8044.4776     -8044.4776     -8119.8059     -8119.8059      291.52862      291.52862      24077.923      24077.923      676.45435      676.45435    
    128000  -8041.9588     -8041.9588     -8118.5374     -8118.5374      296.36715      296.36715      24096.456      24096.456     -573.10914     -573.10914    
Loop time of 111.147 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.56     | 110.56     | 110.56     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082036   | 0.082036   | 0.082036   |   0.0 |  0.07
Output  | 0.00021721 | 0.00021721 | 0.00021721 |   0.0 |  0.00
Modify  | 0.44037    | 0.44037    | 0.44037    |   0.0 |  0.40
Other   |            | 0.06205    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2944 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116206 ave      116206 max      116206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116206
Ave neighs/atom = 58.103
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.206990542747, Press = 1.44921143823373
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    128000  -8041.9588     -8041.9588     -8118.5374     -8118.5374      296.36715      296.36715      24096.456      24096.456     -573.10914     -573.10914    
    129000  -8044.1491     -8044.1491     -8119.9156     -8119.9156      293.22441      293.22441      24099.72       24099.72      -836.2712      -836.2712     
Loop time of 113.125 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.424 hours/ns, 8.840 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.53     | 112.53     | 112.53     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082346   | 0.082346   | 0.082346   |   0.0 |  0.07
Output  | 0.00016963 | 0.00016963 | 0.00016963 |   0.0 |  0.00
Modify  | 0.44501    | 0.44501    | 0.44501    |   0.0 |  0.39
Other   |            | 0.06289    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2943 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       116174 ave      116174 max      116174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0