# 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.850998893380165*${_u_distance}
variable latticeconst_converted equal 2.850998893380165*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.85099889338017
Lattice spacing in x,y,z = 2.8509989 2.8509989 2.8509989
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (28.509989 28.509989 28.509989)
  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.509989 28.509989 28.509989)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_JelinekGrohHorstemeyer_2012_AlSiMgCuFe__MO_262519520678_002
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -8473.9133     -8473.9133     -8559.9963     -8559.9963      333.15         333.15         23173.474      23173.474      3967.7637      3967.7637    
      1000  -8391.9972     -8391.9972     -8474.5491     -8474.5491      319.48436      319.48436      23511.379      23511.379      3045.7689      3045.7689    
Loop time of 230.774 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.104 hours/ns, 4.333 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.27     | 230.27     | 230.27     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097785   | 0.097785   | 0.097785   |   0.0 |  0.04
Output  | 0.00020957 | 0.00020957 | 0.00020957 |   0.0 |  0.00
Modify  | 0.34866    | 0.34866    | 0.34866    |   0.0 |  0.15
Other   |            | 0.05998    |            |       |  0.03

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

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

Performance: 0.383 ns/day, 62.645 hours/ns, 4.434 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 225        | 225        | 225        |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10181    | 0.10181    | 0.10181    |   0.0 |  0.05
Output  | 0.00020565 | 0.00020565 | 0.00020565 |   0.0 |  0.00
Modify  | 0.35935    | 0.35935    | 0.35935    |   0.0 |  0.16
Other   |            | 0.06161    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4147 ave        4147 max        4147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244908 ave      244908 max      244908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.384 ns/day, 62.577 hours/ns, 4.439 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.75     | 224.75     | 224.75     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10118    | 0.10118    | 0.10118    |   0.0 |  0.04
Output  | 0.00020158 | 0.00020158 | 0.00020158 |   0.0 |  0.00
Modify  | 0.36196    | 0.36196    | 0.36196    |   0.0 |  0.16
Other   |            | 0.06142    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4146 ave        4146 max        4146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243686 ave      243686 max      243686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.379 ns/day, 63.364 hours/ns, 4.384 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.58     | 227.58     | 227.58     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10116    | 0.10116    | 0.10116    |   0.0 |  0.04
Output  | 0.00020509 | 0.00020509 | 0.00020509 |   0.0 |  0.00
Modify  | 0.36407    | 0.36407    | 0.36407    |   0.0 |  0.16
Other   |            | 0.062      |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4145 ave        4145 max        4145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244106 ave      244106 max      244106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.380 ns/day, 63.088 hours/ns, 4.403 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.59     | 226.59     | 226.59     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10096    | 0.10096    | 0.10096    |   0.0 |  0.04
Output  | 0.0001646  | 0.0001646  | 0.0001646  |   0.0 |  0.00
Modify  | 0.36152    | 0.36152    | 0.36152    |   0.0 |  0.16
Other   |            | 0.06162    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4133 ave        4133 max        4133 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243782 ave      243782 max      243782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.379 ns/day, 63.250 hours/ns, 4.392 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.14     | 227.14     | 227.14     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10242    | 0.10242    | 0.10242    |   0.0 |  0.04
Output  | 0.00016442 | 0.00016442 | 0.00016442 |   0.0 |  0.00
Modify  | 0.3904     | 0.3904     | 0.3904     |   0.0 |  0.17
Other   |            | 0.06218    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4157 ave        4157 max        4157 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244344 ave      244344 max      244344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.377 ns/day, 63.689 hours/ns, 4.362 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.72     | 228.72     | 228.72     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10264    | 0.10264    | 0.10264    |   0.0 |  0.04
Output  | 0.00016395 | 0.00016395 | 0.00016395 |   0.0 |  0.00
Modify  | 0.39328    | 0.39328    | 0.39328    |   0.0 |  0.17
Other   |            | 0.06193    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4154 ave        4154 max        4154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244946 ave      244946 max      244946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.380 ns/day, 63.105 hours/ns, 4.402 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.63     | 226.63     | 226.63     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10083    | 0.10083    | 0.10083    |   0.0 |  0.04
Output  | 0.00016472 | 0.00016472 | 0.00016472 |   0.0 |  0.00
Modify  | 0.3817     | 0.3817     | 0.3817     |   0.0 |  0.17
Other   |            | 0.06158    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4136 ave        4136 max        4136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244964 ave      244964 max      244964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.379 ns/day, 63.301 hours/ns, 4.388 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.34     | 227.34     | 227.34     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10183    | 0.10183    | 0.10183    |   0.0 |  0.04
Output  | 0.0001644  | 0.0001644  | 0.0001644  |   0.0 |  0.00
Modify  | 0.38495    | 0.38495    | 0.38495    |   0.0 |  0.17
Other   |            | 0.06164    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4158 ave        4158 max        4158 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244106 ave      244106 max      244106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.377 ns/day, 63.580 hours/ns, 4.369 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.33     | 228.33     | 228.33     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10324    | 0.10324    | 0.10324    |   0.0 |  0.05
Output  | 0.00016523 | 0.00016523 | 0.00016523 |   0.0 |  0.00
Modify  | 0.39107    | 0.39107    | 0.39107    |   0.0 |  0.17
Other   |            | 0.06245    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4171 ave        4171 max        4171 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243994 ave      243994 max      243994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.379 ns/day, 63.407 hours/ns, 4.381 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.71     | 227.71     | 227.71     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10232    | 0.10232    | 0.10232    |   0.0 |  0.04
Output  | 0.00019896 | 0.00019896 | 0.00019896 |   0.0 |  0.00
Modify  | 0.38729    | 0.38729    | 0.38729    |   0.0 |  0.17
Other   |            | 0.06121    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4162 ave        4162 max        4162 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244322 ave      244322 max      244322 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.370 ns/day, 64.865 hours/ns, 4.282 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 232.95     | 232.95     | 232.95     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10357    | 0.10357    | 0.10357    |   0.0 |  0.04
Output  | 0.00016565 | 0.00016565 | 0.00016565 |   0.0 |  0.00
Modify  | 0.39594    | 0.39594    | 0.39594    |   0.0 |  0.17
Other   |            | 0.06214    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4150 ave        4150 max        4150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244440 ave      244440 max      244440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.378 ns/day, 63.548 hours/ns, 4.371 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.23     | 228.23     | 228.23     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10109    | 0.10109    | 0.10109    |   0.0 |  0.04
Output  | 0.00016864 | 0.00016864 | 0.00016864 |   0.0 |  0.00
Modify  | 0.38208    | 0.38208    | 0.38208    |   0.0 |  0.17
Other   |            | 0.06141    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4166 ave        4166 max        4166 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244766 ave      244766 max      244766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.381 ns/day, 63.032 hours/ns, 4.407 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.37     | 226.37     | 226.37     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10098    | 0.10098    | 0.10098    |   0.0 |  0.04
Output  | 0.00044429 | 0.00044429 | 0.00044429 |   0.0 |  0.00
Modify  | 0.38544    | 0.38544    | 0.38544    |   0.0 |  0.17
Other   |            | 0.06165    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4151 ave        4151 max        4151 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243954 ave      243954 max      243954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.380 ns/day, 63.222 hours/ns, 4.394 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.05     | 227.05     | 227.05     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10079    | 0.10079    | 0.10079    |   0.0 |  0.04
Output  | 0.00016489 | 0.00016489 | 0.00016489 |   0.0 |  0.00
Modify  | 0.38584    | 0.38584    | 0.38584    |   0.0 |  0.17
Other   |            | 0.06139    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4138 ave        4138 max        4138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243694 ave      243694 max      243694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.375 ns/day, 63.949 hours/ns, 4.344 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.67     | 229.67     | 229.67     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10172    | 0.10172    | 0.10172    |   0.0 |  0.04
Output  | 0.00016368 | 0.00016368 | 0.00016368 |   0.0 |  0.00
Modify  | 0.38868    | 0.38868    | 0.38868    |   0.0 |  0.17
Other   |            | 0.06161    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4144 ave        4144 max        4144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244300 ave      244300 max      244300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.371 ns/day, 64.622 hours/ns, 4.299 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 232.08     | 232.08     | 232.08     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10337    | 0.10337    | 0.10337    |   0.0 |  0.04
Output  | 0.0001673  | 0.0001673  | 0.0001673  |   0.0 |  0.00
Modify  | 0.39634    | 0.39634    | 0.39634    |   0.0 |  0.17
Other   |            | 0.06248    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4151 ave        4151 max        4151 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244344 ave      244344 max      244344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.372 ns/day, 64.585 hours/ns, 4.301 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.95     | 231.95     | 231.95     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10241    | 0.10241    | 0.10241    |   0.0 |  0.04
Output  | 0.00016551 | 0.00016551 | 0.00016551 |   0.0 |  0.00
Modify  | 0.39379    | 0.39379    | 0.39379    |   0.0 |  0.17
Other   |            | 0.06245    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4145 ave        4145 max        4145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244650 ave      244650 max      244650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.803 hours/ns, 4.354 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.13     | 229.13     | 229.13     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1023     | 0.1023     | 0.1023     |   0.0 |  0.04
Output  | 0.00024151 | 0.00024151 | 0.00024151 |   0.0 |  0.00
Modify  | 0.39647    | 0.39647    | 0.39647    |   0.0 |  0.17
Other   |            | 0.06276    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4134 ave        4134 max        4134 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244328 ave      244328 max      244328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.811 hours/ns, 4.353 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.16     | 229.16     | 229.16     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10239    | 0.10239    | 0.10239    |   0.0 |  0.04
Output  | 0.00020992 | 0.00020992 | 0.00020992 |   0.0 |  0.00
Modify  | 0.39038    | 0.39038    | 0.39038    |   0.0 |  0.17
Other   |            | 0.0615     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4143 ave        4143 max        4143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243690 ave      243690 max      243690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.373 ns/day, 64.315 hours/ns, 4.319 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.97     | 230.97     | 230.97     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10383    | 0.10383    | 0.10383    |   0.0 |  0.04
Output  | 0.00016274 | 0.00016274 | 0.00016274 |   0.0 |  0.00
Modify  | 0.39714    | 0.39714    | 0.39714    |   0.0 |  0.17
Other   |            | 0.06245    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4128 ave        4128 max        4128 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243754 ave      243754 max      243754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.772 hours/ns, 4.356 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.02     | 229.02     | 229.02     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10267    | 0.10267    | 0.10267    |   0.0 |  0.04
Output  | 0.00018158 | 0.00018158 | 0.00018158 |   0.0 |  0.00
Modify  | 0.39433    | 0.39433    | 0.39433    |   0.0 |  0.17
Other   |            | 0.06273    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4131 ave        4131 max        4131 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244230 ave      244230 max      244230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244230
Ave neighs/atom = 122.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 = 333.016168506072, Press = 3.56257747886462
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -8390.8375     -8390.8375     -8475.5854     -8475.5854      327.98328      327.98328      23511.713      23511.713      2875.8619      2875.8619    
     23000  -8385.1888     -8385.1888     -8475.0103     -8475.0103      347.61826      347.61826      23529.33       23529.33       2083.3363      2083.3363    
Loop time of 229.563 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.767 hours/ns, 4.356 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.01     | 229.01     | 229.01     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10209    | 0.10209    | 0.10209    |   0.0 |  0.04
Output  | 0.00020808 | 0.00020808 | 0.00020808 |   0.0 |  0.00
Modify  | 0.38699    | 0.38699    | 0.38699    |   0.0 |  0.17
Other   |            | 0.06135    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4142 ave        4142 max        4142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244828 ave      244828 max      244828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.911 hours/ns, 4.346 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.52     | 229.52     | 229.52     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10233    | 0.10233    | 0.10233    |   0.0 |  0.04
Output  | 0.00016537 | 0.00016537 | 0.00016537 |   0.0 |  0.00
Modify  | 0.39162    | 0.39162    | 0.39162    |   0.0 |  0.17
Other   |            | 0.062      |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4143 ave        4143 max        4143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244714 ave      244714 max      244714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.381 ns/day, 62.997 hours/ns, 4.409 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.24     | 226.24     | 226.24     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1006     | 0.1006     | 0.1006     |   0.0 |  0.04
Output  | 0.00016524 | 0.00016524 | 0.00016524 |   0.0 |  0.00
Modify  | 0.38373    | 0.38373    | 0.38373    |   0.0 |  0.17
Other   |            | 0.06165    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4138 ave        4138 max        4138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243488 ave      243488 max      243488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.381 ns/day, 63.032 hours/ns, 4.407 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.36     | 226.36     | 226.36     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10217    | 0.10217    | 0.10217    |   0.0 |  0.05
Output  | 0.00023387 | 0.00023387 | 0.00023387 |   0.0 |  0.00
Modify  | 0.38467    | 0.38467    | 0.38467    |   0.0 |  0.17
Other   |            | 0.0616     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4130 ave        4130 max        4130 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243336 ave      243336 max      243336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.379 ns/day, 63.249 hours/ns, 4.392 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.14     | 227.14     | 227.14     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.102      | 0.102      | 0.102      |   0.0 |  0.04
Output  | 0.00016559 | 0.00016559 | 0.00016559 |   0.0 |  0.00
Modify  | 0.38769    | 0.38769    | 0.38769    |   0.0 |  0.17
Other   |            | 0.06194    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4137 ave        4137 max        4137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244142 ave      244142 max      244142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.382 ns/day, 62.811 hours/ns, 4.422 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 225.58     | 225.58     | 225.58     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10085    | 0.10085    | 0.10085    |   0.0 |  0.04
Output  | 0.00016399 | 0.00016399 | 0.00016399 |   0.0 |  0.00
Modify  | 0.38006    | 0.38006    | 0.38006    |   0.0 |  0.17
Other   |            | 0.06136    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4142 ave        4142 max        4142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244708 ave      244708 max      244708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.380 ns/day, 63.174 hours/ns, 4.397 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.88     | 226.88     | 226.88     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10166    | 0.10166    | 0.10166    |   0.0 |  0.04
Output  | 0.00020183 | 0.00020183 | 0.00020183 |   0.0 |  0.00
Modify  | 0.3843     | 0.3843     | 0.3843     |   0.0 |  0.17
Other   |            | 0.06139    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4147 ave        4147 max        4147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244616 ave      244616 max      244616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.379 ns/day, 63.287 hours/ns, 4.389 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.28     | 227.28     | 227.28     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10178    | 0.10178    | 0.10178    |   0.0 |  0.04
Output  | 0.00016569 | 0.00016569 | 0.00016569 |   0.0 |  0.00
Modify  | 0.38795    | 0.38795    | 0.38795    |   0.0 |  0.17
Other   |            | 0.06193    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4134 ave        4134 max        4134 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243786 ave      243786 max      243786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.375 ns/day, 63.993 hours/ns, 4.341 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.82     | 229.82     | 229.82     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1024     | 0.1024     | 0.1024     |   0.0 |  0.04
Output  | 0.00016645 | 0.00016645 | 0.00016645 |   0.0 |  0.00
Modify  | 0.38967    | 0.38967    | 0.38967    |   0.0 |  0.17
Other   |            | 0.0625     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4139 ave        4139 max        4139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243402 ave      243402 max      243402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.377 ns/day, 63.679 hours/ns, 4.362 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.69     | 228.69     | 228.69     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10194    | 0.10194    | 0.10194    |   0.0 |  0.04
Output  | 0.00016208 | 0.00016208 | 0.00016208 |   0.0 |  0.00
Modify  | 0.38952    | 0.38952    | 0.38952    |   0.0 |  0.17
Other   |            | 0.06174    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4148 ave        4148 max        4148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244050 ave      244050 max      244050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.905 hours/ns, 4.347 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.5      | 229.5      | 229.5      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10286    | 0.10286    | 0.10286    |   0.0 |  0.04
Output  | 0.00016538 | 0.00016538 | 0.00016538 |   0.0 |  0.00
Modify  | 0.3891     | 0.3891     | 0.3891     |   0.0 |  0.17
Other   |            | 0.06167    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4128 ave        4128 max        4128 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244632 ave      244632 max      244632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.378 ns/day, 63.451 hours/ns, 4.378 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.87     | 227.87     | 227.87     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10156    | 0.10156    | 0.10156    |   0.0 |  0.04
Output  | 0.00016311 | 0.00016311 | 0.00016311 |   0.0 |  0.00
Modify  | 0.38513    | 0.38513    | 0.38513    |   0.0 |  0.17
Other   |            | 0.06184    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4159 ave        4159 max        4159 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244784 ave      244784 max      244784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.380 ns/day, 63.159 hours/ns, 4.398 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.83     | 226.83     | 226.83     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10161    | 0.10161    | 0.10161    |   0.0 |  0.04
Output  | 0.00016536 | 0.00016536 | 0.00016536 |   0.0 |  0.00
Modify  | 0.38113    | 0.38113    | 0.38113    |   0.0 |  0.17
Other   |            | 0.06109    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4148 ave        4148 max        4148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243984 ave      243984 max      243984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.781 hours/ns, 4.355 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.05     | 229.05     | 229.05     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10358    | 0.10358    | 0.10358    |   0.0 |  0.05
Output  | 0.00020749 | 0.00020749 | 0.00020749 |   0.0 |  0.00
Modify  | 0.39138    | 0.39138    | 0.39138    |   0.0 |  0.17
Other   |            | 0.06233    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4150 ave        4150 max        4150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243764 ave      243764 max      243764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.378 ns/day, 63.532 hours/ns, 4.372 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.16     | 228.16     | 228.16     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10167    | 0.10167    | 0.10167    |   0.0 |  0.04
Output  | 0.00016353 | 0.00016353 | 0.00016353 |   0.0 |  0.00
Modify  | 0.38965    | 0.38965    | 0.38965    |   0.0 |  0.17
Other   |            | 0.06209    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4132 ave        4132 max        4132 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244074 ave      244074 max      244074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.809 hours/ns, 4.353 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.16     | 229.16     | 229.16     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10237    | 0.10237    | 0.10237    |   0.0 |  0.04
Output  | 0.00016655 | 0.00016655 | 0.00016655 |   0.0 |  0.00
Modify  | 0.38959    | 0.38959    | 0.38959    |   0.0 |  0.17
Other   |            | 0.06205    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4157 ave        4157 max        4157 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244682 ave      244682 max      244682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.372 ns/day, 64.528 hours/ns, 4.305 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.74     | 231.74     | 231.74     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1022     | 0.1022     | 0.1022     |   0.0 |  0.04
Output  | 0.00016632 | 0.00016632 | 0.00016632 |   0.0 |  0.00
Modify  | 0.39307    | 0.39307    | 0.39307    |   0.0 |  0.17
Other   |            | 0.0626     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4136 ave        4136 max        4136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244796 ave      244796 max      244796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.371 ns/day, 64.716 hours/ns, 4.292 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 232.41     | 232.41     | 232.41     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10406    | 0.10406    | 0.10406    |   0.0 |  0.04
Output  | 0.00016782 | 0.00016782 | 0.00016782 |   0.0 |  0.00
Modify  | 0.40307    | 0.40307    | 0.40307    |   0.0 |  0.17
Other   |            | 0.06372    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4139 ave        4139 max        4139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244016 ave      244016 max      244016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.372 ns/day, 64.535 hours/ns, 4.304 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.77     | 231.77     | 231.77     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10269    | 0.10269    | 0.10269    |   0.0 |  0.04
Output  | 0.00016371 | 0.00016371 | 0.00016371 |   0.0 |  0.00
Modify  | 0.39279    | 0.39279    | 0.39279    |   0.0 |  0.17
Other   |            | 0.06156    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4133 ave        4133 max        4133 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243618 ave      243618 max      243618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.374 ns/day, 64.123 hours/ns, 4.332 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.28     | 230.28     | 230.28     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10232    | 0.10232    | 0.10232    |   0.0 |  0.04
Output  | 0.00016637 | 0.00016637 | 0.00016637 |   0.0 |  0.00
Modify  | 0.39282    | 0.39282    | 0.39282    |   0.0 |  0.17
Other   |            | 0.06174    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4137 ave        4137 max        4137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243934 ave      243934 max      243934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.380 ns/day, 63.220 hours/ns, 4.394 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.04     | 227.04     | 227.04     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10068    | 0.10068    | 0.10068    |   0.0 |  0.04
Output  | 0.0002058  | 0.0002058  | 0.0002058  |   0.0 |  0.00
Modify  | 0.38612    | 0.38612    | 0.38612    |   0.0 |  0.17
Other   |            | 0.06135    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4124 ave        4124 max        4124 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244074 ave      244074 max      244074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.373 ns/day, 64.298 hours/ns, 4.320 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.91     | 230.91     | 230.91     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10246    | 0.10246    | 0.10246    |   0.0 |  0.04
Output  | 0.00020775 | 0.00020775 | 0.00020775 |   0.0 |  0.00
Modify  | 0.39478    | 0.39478    | 0.39478    |   0.0 |  0.17
Other   |            | 0.06245    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4134 ave        4134 max        4134 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245166 ave      245166 max      245166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.374 ns/day, 64.185 hours/ns, 4.328 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.51     | 230.51     | 230.51     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10241    | 0.10241    | 0.10241    |   0.0 |  0.04
Output  | 0.00016478 | 0.00016478 | 0.00016478 |   0.0 |  0.00
Modify  | 0.39327    | 0.39327    | 0.39327    |   0.0 |  0.17
Other   |            | 0.06192    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4145 ave        4145 max        4145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244792 ave      244792 max      244792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.375 ns/day, 64.007 hours/ns, 4.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    | 229.87     | 229.87     | 229.87     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10302    | 0.10302    | 0.10302    |   0.0 |  0.04
Output  | 0.00016385 | 0.00016385 | 0.00016385 |   0.0 |  0.00
Modify  | 0.39476    | 0.39476    | 0.39476    |   0.0 |  0.17
Other   |            | 0.0626     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4141 ave        4141 max        4141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243918 ave      243918 max      243918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.377 ns/day, 63.668 hours/ns, 4.363 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.65     | 228.65     | 228.65     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10204    | 0.10204    | 0.10204    |   0.0 |  0.04
Output  | 0.00021237 | 0.00021237 | 0.00021237 |   0.0 |  0.00
Modify  | 0.38936    | 0.38936    | 0.38936    |   0.0 |  0.17
Other   |            | 0.06164    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4150 ave        4150 max        4150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244210 ave      244210 max      244210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244210
Ave neighs/atom = 122.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 = 332.856280859669, Press = 2.752894496373
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -8393.5301     -8393.5301     -8479.4824     -8479.4824      332.64433      332.64433      23548.702      23548.702     -867.26001     -867.26001    
     48000  -8387.8115     -8387.8115     -8476.3464     -8476.3464      342.63921      342.63921      23506.836      23506.836      3402.8764      3402.8764    
Loop time of 229.954 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.876 hours/ns, 4.349 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.4      | 229.4      | 229.4      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10245    | 0.10245    | 0.10245    |   0.0 |  0.04
Output  | 0.00016672 | 0.00016672 | 0.00016672 |   0.0 |  0.00
Modify  | 0.39148    | 0.39148    | 0.39148    |   0.0 |  0.17
Other   |            | 0.06266    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4148 ave        4148 max        4148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244176 ave      244176 max      244176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244176
Ave neighs/atom = 122.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 = 332.848316558561, Press = 2.76918621066105
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -8387.8115     -8387.8115     -8476.3464     -8476.3464      342.63921      342.63921      23506.836      23506.836      3402.8764      3402.8764    
     49000  -8390.3278     -8390.3278     -8475.3931     -8475.3931      329.21148      329.21148      23514.274      23514.274      3018.1396      3018.1396    
Loop time of 229.696 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.805 hours/ns, 4.354 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.14     | 229.14     | 229.14     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10261    | 0.10261    | 0.10261    |   0.0 |  0.04
Output  | 0.00016311 | 0.00016311 | 0.00016311 |   0.0 |  0.00
Modify  | 0.39162    | 0.39162    | 0.39162    |   0.0 |  0.17
Other   |            | 0.06188    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4131 ave        4131 max        4131 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244970 ave      244970 max      244970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.375 ns/day, 63.975 hours/ns, 4.342 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.75     | 229.75     | 229.75     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10276    | 0.10276    | 0.10276    |   0.0 |  0.04
Output  | 0.0001641  | 0.0001641  | 0.0001641  |   0.0 |  0.00
Modify  | 0.39402    | 0.39402    | 0.39402    |   0.0 |  0.17
Other   |            | 0.06246    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4141 ave        4141 max        4141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244816 ave      244816 max      244816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.756 hours/ns, 4.357 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.97     | 228.97     | 228.97     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10199    | 0.10199    | 0.10199    |   0.0 |  0.04
Output  | 0.00016565 | 0.00016565 | 0.00016565 |   0.0 |  0.00
Modify  | 0.38707    | 0.38707    | 0.38707    |   0.0 |  0.17
Other   |            | 0.06179    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4137 ave        4137 max        4137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244316 ave      244316 max      244316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.377 ns/day, 63.606 hours/ns, 4.367 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.42     | 228.42     | 228.42     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10249    | 0.10249    | 0.10249    |   0.0 |  0.04
Output  | 0.0014017  | 0.0014017  | 0.0014017  |   0.0 |  0.00
Modify  | 0.39227    | 0.39227    | 0.39227    |   0.0 |  0.17
Other   |            | 0.06206    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4137 ave        4137 max        4137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244028 ave      244028 max      244028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.378 ns/day, 63.543 hours/ns, 4.371 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.2      | 228.2      | 228.2      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10145    | 0.10145    | 0.10145    |   0.0 |  0.04
Output  | 0.00022894 | 0.00022894 | 0.00022894 |   0.0 |  0.00
Modify  | 0.38679    | 0.38679    | 0.38679    |   0.0 |  0.17
Other   |            | 0.06181    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4135 ave        4135 max        4135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243962 ave      243962 max      243962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.375 ns/day, 64.035 hours/ns, 4.338 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.96     | 229.96     | 229.96     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10556    | 0.10556    | 0.10556    |   0.0 |  0.05
Output  | 0.00016355 | 0.00016355 | 0.00016355 |   0.0 |  0.00
Modify  | 0.39484    | 0.39484    | 0.39484    |   0.0 |  0.17
Other   |            | 0.0624     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4133 ave        4133 max        4133 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244278 ave      244278 max      244278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.377 ns/day, 63.744 hours/ns, 4.358 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.92     | 228.92     | 228.92     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10267    | 0.10267    | 0.10267    |   0.0 |  0.04
Output  | 0.00016628 | 0.00016628 | 0.00016628 |   0.0 |  0.00
Modify  | 0.38952    | 0.38952    | 0.38952    |   0.0 |  0.17
Other   |            | 0.06204    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4144 ave        4144 max        4144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244440 ave      244440 max      244440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.380 ns/day, 63.185 hours/ns, 4.396 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.92     | 226.92     | 226.92     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10081    | 0.10081    | 0.10081    |   0.0 |  0.04
Output  | 0.00016384 | 0.00016384 | 0.00016384 |   0.0 |  0.00
Modify  | 0.38384    | 0.38384    | 0.38384    |   0.0 |  0.17
Other   |            | 0.06207    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4144 ave        4144 max        4144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244676 ave      244676 max      244676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.372 ns/day, 64.450 hours/ns, 4.310 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.46     | 231.46     | 231.46     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10414    | 0.10414    | 0.10414    |   0.0 |  0.04
Output  | 0.000165   | 0.000165   | 0.000165   |   0.0 |  0.00
Modify  | 0.39962    | 0.39962    | 0.39962    |   0.0 |  0.17
Other   |            | 0.06287    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4156 ave        4156 max        4156 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243866 ave      243866 max      243866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.380 ns/day, 63.147 hours/ns, 4.399 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.78     | 226.78     | 226.78     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10065    | 0.10065    | 0.10065    |   0.0 |  0.04
Output  | 0.00016456 | 0.00016456 | 0.00016456 |   0.0 |  0.00
Modify  | 0.3834     | 0.3834     | 0.3834     |   0.0 |  0.17
Other   |            | 0.06169    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4132 ave        4132 max        4132 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243746 ave      243746 max      243746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.378 ns/day, 63.482 hours/ns, 4.376 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.98     | 227.98     | 227.98     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1019     | 0.1019     | 0.1019     |   0.0 |  0.04
Output  | 0.00022676 | 0.00022676 | 0.00022676 |   0.0 |  0.00
Modify  | 0.38995    | 0.38995    | 0.38995    |   0.0 |  0.17
Other   |            | 0.06156    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4135 ave        4135 max        4135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244148 ave      244148 max      244148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244148
Ave neighs/atom = 122.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 = 332.875308054405, Press = 0.934261616130575
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -8389.94       -8389.94       -8476.1769     -8476.1769      333.74591      333.74591      23544.042      23544.042      446.64412      446.64412    
     60000  -8394.4542     -8394.4542     -8477.3602     -8477.3602      320.85491      320.85491      23543.16       23543.16      -14.796966     -14.796966    
Loop time of 228.487 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.469 hours/ns, 4.377 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.93     | 227.93     | 227.93     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1023     | 0.1023     | 0.1023     |   0.0 |  0.04
Output  | 0.0001645  | 0.0001645  | 0.0001645  |   0.0 |  0.00
Modify  | 0.39172    | 0.39172    | 0.39172    |   0.0 |  0.17
Other   |            | 0.06231    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4140 ave        4140 max        4140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244442 ave      244442 max      244442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.382 ns/day, 62.788 hours/ns, 4.424 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 225.49     | 225.49     | 225.49     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10095    | 0.10095    | 0.10095    |   0.0 |  0.04
Output  | 0.00021021 | 0.00021021 | 0.00021021 |   0.0 |  0.00
Modify  | 0.38492    | 0.38492    | 0.38492    |   0.0 |  0.17
Other   |            | 0.0617     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4141 ave        4141 max        4141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244402 ave      244402 max      244402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.385 ns/day, 62.389 hours/ns, 4.452 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.06     | 224.06     | 224.06     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10061    | 0.10061    | 0.10061    |   0.0 |  0.04
Output  | 0.00016527 | 0.00016527 | 0.00016527 |   0.0 |  0.00
Modify  | 0.37809    | 0.37809    | 0.37809    |   0.0 |  0.17
Other   |            | 0.06075    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4176 ave        4176 max        4176 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244038 ave      244038 max      244038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.381 ns/day, 62.960 hours/ns, 4.412 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.11     | 226.11     | 226.11     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10191    | 0.10191    | 0.10191    |   0.0 |  0.04
Output  | 0.00016551 | 0.00016551 | 0.00016551 |   0.0 |  0.00
Modify  | 0.38367    | 0.38367    | 0.38367    |   0.0 |  0.17
Other   |            | 0.06112    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4148 ave        4148 max        4148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243898 ave      243898 max      243898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.379 ns/day, 63.316 hours/ns, 4.387 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.39     | 227.39     | 227.39     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10228    | 0.10228    | 0.10228    |   0.0 |  0.04
Output  | 0.00016475 | 0.00016475 | 0.00016475 |   0.0 |  0.00
Modify  | 0.3839     | 0.3839     | 0.3839     |   0.0 |  0.17
Other   |            | 0.06124    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4154 ave        4154 max        4154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244262 ave      244262 max      244262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.828 hours/ns, 4.352 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.23     | 229.23     | 229.23     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10313    | 0.10313    | 0.10313    |   0.0 |  0.04
Output  | 0.00016632 | 0.00016632 | 0.00016632 |   0.0 |  0.00
Modify  | 0.38939    | 0.38939    | 0.38939    |   0.0 |  0.17
Other   |            | 0.06189    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4166 ave        4166 max        4166 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244912 ave      244912 max      244912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.779 hours/ns, 4.355 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.05     | 229.05     | 229.05     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10264    | 0.10264    | 0.10264    |   0.0 |  0.04
Output  | 0.00020188 | 0.00020188 | 0.00020188 |   0.0 |  0.00
Modify  | 0.38851    | 0.38851    | 0.38851    |   0.0 |  0.17
Other   |            | 0.06186    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4155 ave        4155 max        4155 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244414 ave      244414 max      244414 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.375 ns/day, 63.960 hours/ns, 4.343 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.7      | 229.7      | 229.7      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10252    | 0.10252    | 0.10252    |   0.0 |  0.04
Output  | 0.00020555 | 0.00020555 | 0.00020555 |   0.0 |  0.00
Modify  | 0.39367    | 0.39367    | 0.39367    |   0.0 |  0.17
Other   |            | 0.06241    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4138 ave        4138 max        4138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244042 ave      244042 max      244042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.377 ns/day, 63.579 hours/ns, 4.369 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.34     | 228.34     | 228.34     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10099    | 0.10099    | 0.10099    |   0.0 |  0.04
Output  | 0.00016455 | 0.00016455 | 0.00016455 |   0.0 |  0.00
Modify  | 0.38482    | 0.38482    | 0.38482    |   0.0 |  0.17
Other   |            | 0.0611     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4143 ave        4143 max        4143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244326 ave      244326 max      244326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.375 ns/day, 63.952 hours/ns, 4.344 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.67     | 229.67     | 229.67     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1019     | 0.1019     | 0.1019     |   0.0 |  0.04
Output  | 0.00016212 | 0.00016212 | 0.00016212 |   0.0 |  0.00
Modify  | 0.39154    | 0.39154    | 0.39154    |   0.0 |  0.17
Other   |            | 0.06238    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4152 ave        4152 max        4152 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244466 ave      244466 max      244466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.377 ns/day, 63.742 hours/ns, 4.358 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.91     | 228.91     | 228.91     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10346    | 0.10346    | 0.10346    |   0.0 |  0.05
Output  | 0.00016563 | 0.00016563 | 0.00016563 |   0.0 |  0.00
Modify  | 0.3931     | 0.3931     | 0.3931     |   0.0 |  0.17
Other   |            | 0.06243    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4160 ave        4160 max        4160 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244786 ave      244786 max      244786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.805 hours/ns, 4.354 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.13     | 229.13     | 229.13     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10392    | 0.10392    | 0.10392    |   0.0 |  0.05
Output  | 0.00016379 | 0.00016379 | 0.00016379 |   0.0 |  0.00
Modify  | 0.39773    | 0.39773    | 0.39773    |   0.0 |  0.17
Other   |            | 0.06263    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4139 ave        4139 max        4139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244472 ave      244472 max      244472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.372 ns/day, 64.441 hours/ns, 4.311 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.43     | 231.43     | 231.43     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1035     | 0.1035     | 0.1035     |   0.0 |  0.04
Output  | 0.00021151 | 0.00021151 | 0.00021151 |   0.0 |  0.00
Modify  | 0.39781    | 0.39781    | 0.39781    |   0.0 |  0.17
Other   |            | 0.06236    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4139 ave        4139 max        4139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243926 ave      243926 max      243926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.372 ns/day, 64.445 hours/ns, 4.310 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.44     | 231.44     | 231.44     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10349    | 0.10349    | 0.10349    |   0.0 |  0.04
Output  | 0.00025419 | 0.00025419 | 0.00025419 |   0.0 |  0.00
Modify  | 0.39893    | 0.39893    | 0.39893    |   0.0 |  0.17
Other   |            | 0.06226    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4142 ave        4142 max        4142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243908 ave      243908 max      243908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.377 ns/day, 63.626 hours/ns, 4.366 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.49     | 228.49     | 228.49     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10264    | 0.10264    | 0.10264    |   0.0 |  0.04
Output  | 0.00016558 | 0.00016558 | 0.00016558 |   0.0 |  0.00
Modify  | 0.3936     | 0.3936     | 0.3936     |   0.0 |  0.17
Other   |            | 0.06287    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4154 ave        4154 max        4154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243902 ave      243902 max      243902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.374 ns/day, 64.181 hours/ns, 4.328 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.49     | 230.49     | 230.49     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10316    | 0.10316    | 0.10316    |   0.0 |  0.04
Output  | 0.00016332 | 0.00016332 | 0.00016332 |   0.0 |  0.00
Modify  | 0.39515    | 0.39515    | 0.39515    |   0.0 |  0.17
Other   |            | 0.06245    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4143 ave        4143 max        4143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244858 ave      244858 max      244858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.377 ns/day, 63.739 hours/ns, 4.358 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.91     | 228.91     | 228.91     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10256    | 0.10256    | 0.10256    |   0.0 |  0.04
Output  | 0.00016958 | 0.00016958 | 0.00016958 |   0.0 |  0.00
Modify  | 0.38863    | 0.38863    | 0.38863    |   0.0 |  0.17
Other   |            | 0.06182    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4156 ave        4156 max        4156 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245228 ave      245228 max      245228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.380 ns/day, 63.192 hours/ns, 4.396 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.94     | 226.94     | 226.94     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10214    | 0.10214    | 0.10214    |   0.0 |  0.04
Output  | 0.00022467 | 0.00022467 | 0.00022467 |   0.0 |  0.00
Modify  | 0.38812    | 0.38812    | 0.38812    |   0.0 |  0.17
Other   |            | 0.06154    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4143 ave        4143 max        4143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244202 ave      244202 max      244202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244202
Ave neighs/atom = 122.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 = 332.759419082151, Press = 0.74387006182985
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -8392.8603     -8392.8603     -8476.0522     -8476.0522      321.96125      321.96125      23564.073      23564.073     -1075.1725     -1075.1725    
     78000  -8388.8622     -8388.8622     -8474.2045     -8474.2045      330.28347      330.28347      23568.117      23568.117     -480.6719      -480.6719     
Loop time of 229.822 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.840 hours/ns, 4.351 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.27     | 229.27     | 229.27     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10214    | 0.10214    | 0.10214    |   0.0 |  0.04
Output  | 0.00019852 | 0.00019852 | 0.00019852 |   0.0 |  0.00
Modify  | 0.39136    | 0.39136    | 0.39136    |   0.0 |  0.17
Other   |            | 0.06193    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4137 ave        4137 max        4137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243900 ave      243900 max      243900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.374 ns/day, 64.137 hours/ns, 4.331 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.33     | 230.33     | 230.33     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10322    | 0.10322    | 0.10322    |   0.0 |  0.04
Output  | 0.0001991  | 0.0001991  | 0.0001991  |   0.0 |  0.00
Modify  | 0.39652    | 0.39652    | 0.39652    |   0.0 |  0.17
Other   |            | 0.06241    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4134 ave        4134 max        4134 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243896 ave      243896 max      243896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.809 hours/ns, 4.353 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.16     | 229.16     | 229.16     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10151    | 0.10151    | 0.10151    |   0.0 |  0.04
Output  | 0.0001655  | 0.0001655  | 0.0001655  |   0.0 |  0.00
Modify  | 0.39107    | 0.39107    | 0.39107    |   0.0 |  0.17
Other   |            | 0.06257    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4153 ave        4153 max        4153 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244464 ave      244464 max      244464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.375 ns/day, 63.921 hours/ns, 4.346 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.56     | 229.56     | 229.56     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10292    | 0.10292    | 0.10292    |   0.0 |  0.04
Output  | 0.00016456 | 0.00016456 | 0.00016456 |   0.0 |  0.00
Modify  | 0.39253    | 0.39253    | 0.39253    |   0.0 |  0.17
Other   |            | 0.06237    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4176 ave        4176 max        4176 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244944 ave      244944 max      244944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.761 hours/ns, 4.357 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.99     | 228.99     | 228.99     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10195    | 0.10195    | 0.10195    |   0.0 |  0.04
Output  | 0.00016581 | 0.00016581 | 0.00016581 |   0.0 |  0.00
Modify  | 0.38284    | 0.38284    | 0.38284    |   0.0 |  0.17
Other   |            | 0.06146    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4156 ave        4156 max        4156 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244738 ave      244738 max      244738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.378 ns/day, 63.435 hours/ns, 4.379 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.82     | 227.82     | 227.82     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10185    | 0.10185    | 0.10185    |   0.0 |  0.04
Output  | 0.00016585 | 0.00016585 | 0.00016585 |   0.0 |  0.00
Modify  | 0.38657    | 0.38657    | 0.38657    |   0.0 |  0.17
Other   |            | 0.0621     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4144 ave        4144 max        4144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243728 ave      243728 max      243728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.381 ns/day, 62.966 hours/ns, 4.412 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.13     | 226.13     | 226.13     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10074    | 0.10074    | 0.10074    |   0.0 |  0.04
Output  | 0.00016528 | 0.00016528 | 0.00016528 |   0.0 |  0.00
Modify  | 0.3819     | 0.3819     | 0.3819     |   0.0 |  0.17
Other   |            | 0.06125    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4142 ave        4142 max        4142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244060 ave      244060 max      244060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.382 ns/day, 62.878 hours/ns, 4.418 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 225.81     | 225.81     | 225.81     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10161    | 0.10161    | 0.10161    |   0.0 |  0.04
Output  | 0.00016615 | 0.00016615 | 0.00016615 |   0.0 |  0.00
Modify  | 0.38462    | 0.38462    | 0.38462    |   0.0 |  0.17
Other   |            | 0.06148    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4140 ave        4140 max        4140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244216 ave      244216 max      244216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244216
Ave neighs/atom = 122.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 = 332.782539889575, Press = 2.13938347439262
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -8388.9081     -8388.9081     -8476.3286     -8476.3286      338.3263       338.3263       23559.834      23559.834     -757.47738     -757.47738    
     86000  -8393.5117     -8393.5117     -8477.246      -8477.246       324.06027      324.06027      23496.538      23496.538      3792.9151      3792.9151    
Loop time of 227.586 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.380 ns/day, 63.218 hours/ns, 4.394 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.03     | 227.03     | 227.03     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10249    | 0.10249    | 0.10249    |   0.0 |  0.05
Output  | 0.00016374 | 0.00016374 | 0.00016374 |   0.0 |  0.00
Modify  | 0.38892    | 0.38892    | 0.38892    |   0.0 |  0.17
Other   |            | 0.06179    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4154 ave        4154 max        4154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244042 ave      244042 max      244042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.762 hours/ns, 4.356 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.99     | 228.99     | 228.99     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10148    | 0.10148    | 0.10148    |   0.0 |  0.04
Output  | 0.00016546 | 0.00016546 | 0.00016546 |   0.0 |  0.00
Modify  | 0.38858    | 0.38858    | 0.38858    |   0.0 |  0.17
Other   |            | 0.06179    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4140 ave        4140 max        4140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245058 ave      245058 max      245058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.817 hours/ns, 4.353 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.19     | 229.19     | 229.19     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10232    | 0.10232    | 0.10232    |   0.0 |  0.04
Output  | 0.00016353 | 0.00016353 | 0.00016353 |   0.0 |  0.00
Modify  | 0.388      | 0.388      | 0.388      |   0.0 |  0.17
Other   |            | 0.06158    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4158 ave        4158 max        4158 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244470 ave      244470 max      244470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.380 ns/day, 63.167 hours/ns, 4.398 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.85     | 226.85     | 226.85     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10122    | 0.10122    | 0.10122    |   0.0 |  0.04
Output  | 0.00016545 | 0.00016545 | 0.00016545 |   0.0 |  0.00
Modify  | 0.38689    | 0.38689    | 0.38689    |   0.0 |  0.17
Other   |            | 0.06104    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4138 ave        4138 max        4138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243894 ave      243894 max      243894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.375 ns/day, 64.004 hours/ns, 4.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    | 229.86     | 229.86     | 229.86     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10134    | 0.10134    | 0.10134    |   0.0 |  0.04
Output  | 0.0020999  | 0.0020999  | 0.0020999  |   0.0 |  0.00
Modify  | 0.39       | 0.39       | 0.39       |   0.0 |  0.17
Other   |            | 0.06174    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4141 ave        4141 max        4141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244114 ave      244114 max      244114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.374 ns/day, 64.180 hours/ns, 4.328 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.49     | 230.49     | 230.49     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10372    | 0.10372    | 0.10372    |   0.0 |  0.04
Output  | 0.00016825 | 0.00016825 | 0.00016825 |   0.0 |  0.00
Modify  | 0.39391    | 0.39391    | 0.39391    |   0.0 |  0.17
Other   |            | 0.06244    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4149 ave        4149 max        4149 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243810 ave      243810 max      243810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.373 ns/day, 64.350 hours/ns, 4.317 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.09     | 231.09     | 231.09     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10316    | 0.10316    | 0.10316    |   0.0 |  0.04
Output  | 0.00016368 | 0.00016368 | 0.00016368 |   0.0 |  0.00
Modify  | 0.39844    | 0.39844    | 0.39844    |   0.0 |  0.17
Other   |            | 0.06295    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4150 ave        4150 max        4150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243964 ave      243964 max      243964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.800 hours/ns, 4.354 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.13     | 229.13     | 229.13     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10229    | 0.10229    | 0.10229    |   0.0 |  0.04
Output  | 0.00022677 | 0.00022677 | 0.00022677 |   0.0 |  0.00
Modify  | 0.38779    | 0.38779    | 0.38779    |   0.0 |  0.17
Other   |            | 0.06183    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4141 ave        4141 max        4141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244948 ave      244948 max      244948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.373 ns/day, 64.328 hours/ns, 4.318 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.02     | 231.02     | 231.02     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10217    | 0.10217    | 0.10217    |   0.0 |  0.04
Output  | 0.00016335 | 0.00016335 | 0.00016335 |   0.0 |  0.00
Modify  | 0.39271    | 0.39271    | 0.39271    |   0.0 |  0.17
Other   |            | 0.06265    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4157 ave        4157 max        4157 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244722 ave      244722 max      244722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.371 ns/day, 64.689 hours/ns, 4.294 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 232.31     | 232.31     | 232.31     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10471    | 0.10471    | 0.10471    |   0.0 |  0.04
Output  | 0.00016288 | 0.00016288 | 0.00016288 |   0.0 |  0.00
Modify  | 0.40173    | 0.40173    | 0.40173    |   0.0 |  0.17
Other   |            | 0.06274    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4156 ave        4156 max        4156 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243906 ave      243906 max      243906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.372 ns/day, 64.437 hours/ns, 4.311 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.41     | 231.41     | 231.41     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10333    | 0.10333    | 0.10333    |   0.0 |  0.04
Output  | 0.00016541 | 0.00016541 | 0.00016541 |   0.0 |  0.00
Modify  | 0.40209    | 0.40209    | 0.40209    |   0.0 |  0.17
Other   |            | 0.06279    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4131 ave        4131 max        4131 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244166 ave      244166 max      244166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244166
Ave neighs/atom = 122.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 = 332.817262930643, Press = 0.315891725379612
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -8391.4925     -8391.4925     -8476.4017     -8476.4017      328.60762      328.60762      23546.697      23546.697      219.50467      219.50467    
     97000  -8387.5537     -8387.5537     -8474.7651     -8474.7651      337.51743      337.51743      23553.584      23553.584      152.75958      152.75958    
Loop time of 231.841 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.400 hours/ns, 4.313 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.28     | 231.28     | 231.28     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10374    | 0.10374    | 0.10374    |   0.0 |  0.04
Output  | 0.0001633  | 0.0001633  | 0.0001633  |   0.0 |  0.00
Modify  | 0.39702    | 0.39702    | 0.39702    |   0.0 |  0.17
Other   |            | 0.06225    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4160 ave        4160 max        4160 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244324 ave      244324 max      244324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.797 hours/ns, 4.354 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.11     | 229.11     | 229.11     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10233    | 0.10233    | 0.10233    |   0.0 |  0.04
Output  | 0.00016333 | 0.00016333 | 0.00016333 |   0.0 |  0.00
Modify  | 0.39323    | 0.39323    | 0.39323    |   0.0 |  0.17
Other   |            | 0.0624     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4143 ave        4143 max        4143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244088 ave      244088 max      244088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.380 ns/day, 63.183 hours/ns, 4.396 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.91     | 226.91     | 226.91     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099726   | 0.099726   | 0.099726   |   0.0 |  0.04
Output  | 0.00016466 | 0.00016466 | 0.00016466 |   0.0 |  0.00
Modify  | 0.38677    | 0.38677    | 0.38677    |   0.0 |  0.17
Other   |            | 0.06107    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4135 ave        4135 max        4135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244244 ave      244244 max      244244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.375 ns/day, 64.019 hours/ns, 4.339 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.91     | 229.91     | 229.91     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10215    | 0.10215    | 0.10215    |   0.0 |  0.04
Output  | 0.00016339 | 0.00016339 | 0.00016339 |   0.0 |  0.00
Modify  | 0.39603    | 0.39603    | 0.39603    |   0.0 |  0.17
Other   |            | 0.06176    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4143 ave        4143 max        4143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243938 ave      243938 max      243938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.382 ns/day, 62.860 hours/ns, 4.419 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 225.75     | 225.75     | 225.75     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099548   | 0.099548   | 0.099548   |   0.0 |  0.04
Output  | 0.00016446 | 0.00016446 | 0.00016446 |   0.0 |  0.00
Modify  | 0.38286    | 0.38286    | 0.38286    |   0.0 |  0.17
Other   |            | 0.06131    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4144 ave        4144 max        4144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244614 ave      244614 max      244614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.377 ns/day, 63.632 hours/ns, 4.365 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.53     | 228.53     | 228.53     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1008     | 0.1008     | 0.1008     |   0.0 |  0.04
Output  | 0.00016244 | 0.00016244 | 0.00016244 |   0.0 |  0.00
Modify  | 0.3871     | 0.3871     | 0.3871     |   0.0 |  0.17
Other   |            | 0.06141    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4145 ave        4145 max        4145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244976 ave      244976 max      244976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.378 ns/day, 63.533 hours/ns, 4.372 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.17     | 228.17     | 228.17     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10048    | 0.10048    | 0.10048    |   0.0 |  0.04
Output  | 0.0002067  | 0.0002067  | 0.0002067  |   0.0 |  0.00
Modify  | 0.38922    | 0.38922    | 0.38922    |   0.0 |  0.17
Other   |            | 0.0612     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4155 ave        4155 max        4155 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244464 ave      244464 max      244464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.373 ns/day, 64.276 hours/ns, 4.322 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.83     | 230.83     | 230.83     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10239    | 0.10239    | 0.10239    |   0.0 |  0.04
Output  | 0.00016542 | 0.00016542 | 0.00016542 |   0.0 |  0.00
Modify  | 0.39782    | 0.39782    | 0.39782    |   0.0 |  0.17
Other   |            | 0.06275    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4155 ave        4155 max        4155 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243800 ave      243800 max      243800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.782 hours/ns, 4.355 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.06     | 229.06     | 229.06     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10148    | 0.10148    | 0.10148    |   0.0 |  0.04
Output  | 0.00022482 | 0.00022482 | 0.00022482 |   0.0 |  0.00
Modify  | 0.38988    | 0.38988    | 0.38988    |   0.0 |  0.17
Other   |            | 0.06137    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4145 ave        4145 max        4145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244194 ave      244194 max      244194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244194
Ave neighs/atom = 122.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 = 332.851844114755, Press = 0.560143494563141
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    105000  -8386.734      -8386.734      -8474.6725     -8474.6725      340.3312       340.3312       23548.774      23548.774      487.58974      487.58974    
    106000  -8388.802      -8388.802      -8476.5176     -8476.5176      339.46837      339.46837      23542.167      23542.167      605.47916      605.47916    
Loop time of 230.168 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 63.936 hours/ns, 4.345 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.62     | 229.62     | 229.62     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10149    | 0.10149    | 0.10149    |   0.0 |  0.04
Output  | 0.00016436 | 0.00016436 | 0.00016436 |   0.0 |  0.00
Modify  | 0.389      | 0.389      | 0.389      |   0.0 |  0.17
Other   |            | 0.0616     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4151 ave        4151 max        4151 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244246 ave      244246 max      244246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244246
Ave neighs/atom = 122.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 = 332.845628717366, Press = 0.396902937128151
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    106000  -8388.802      -8388.802      -8476.5176     -8476.5176      339.46837      339.46837      23542.167      23542.167      605.47916      605.47916    
    107000  -8390.4582     -8390.4582     -8477.5751     -8477.5751      337.15168      337.15168      23562.403      23562.403     -1285.8325     -1285.8325    
Loop time of 228.504 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.473 hours/ns, 4.376 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.95     | 227.95     | 227.95     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10131    | 0.10131    | 0.10131    |   0.0 |  0.04
Output  | 0.0001639  | 0.0001639  | 0.0001639  |   0.0 |  0.00
Modify  | 0.39086    | 0.39086    | 0.39086    |   0.0 |  0.17
Other   |            | 0.0617     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4142 ave        4142 max        4142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244364 ave      244364 max      244364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.369 ns/day, 64.973 hours/ns, 4.275 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.34     | 233.34     | 233.34     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10316    | 0.10316    | 0.10316    |   0.0 |  0.04
Output  | 0.000165   | 0.000165   | 0.000165   |   0.0 |  0.00
Modify  | 0.40023    | 0.40023    | 0.40023    |   0.0 |  0.17
Other   |            | 0.06202    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4141 ave        4141 max        4141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243882 ave      243882 max      243882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.375 ns/day, 63.962 hours/ns, 4.343 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.7      | 229.7      | 229.7      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1024     | 0.1024     | 0.1024     |   0.0 |  0.04
Output  | 0.00016324 | 0.00016324 | 0.00016324 |   0.0 |  0.00
Modify  | 0.39683    | 0.39683    | 0.39683    |   0.0 |  0.17
Other   |            | 0.06285    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4141 ave        4141 max        4141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243948 ave      243948 max      243948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.380 ns/day, 63.200 hours/ns, 4.395 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.97     | 226.97     | 226.97     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10106    | 0.10106    | 0.10106    |   0.0 |  0.04
Output  | 0.00016335 | 0.00016335 | 0.00016335 |   0.0 |  0.00
Modify  | 0.38648    | 0.38648    | 0.38648    |   0.0 |  0.17
Other   |            | 0.06096    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4147 ave        4147 max        4147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244522 ave      244522 max      244522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.373 ns/day, 64.287 hours/ns, 4.321 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.88     | 230.88     | 230.88     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10158    | 0.10158    | 0.10158    |   0.0 |  0.04
Output  | 0.00016533 | 0.00016533 | 0.00016533 |   0.0 |  0.00
Modify  | 0.39519    | 0.39519    | 0.39519    |   0.0 |  0.17
Other   |            | 0.06173    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4140 ave        4140 max        4140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244910 ave      244910 max      244910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.375 ns/day, 64.056 hours/ns, 4.336 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.05     | 230.05     | 230.05     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10189    | 0.10189    | 0.10189    |   0.0 |  0.04
Output  | 0.00016649 | 0.00016649 | 0.00016649 |   0.0 |  0.00
Modify  | 0.39244    | 0.39244    | 0.39244    |   0.0 |  0.17
Other   |            | 0.06182    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4137 ave        4137 max        4137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244436 ave      244436 max      244436 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.374 ns/day, 64.122 hours/ns, 4.332 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.28     | 230.28     | 230.28     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10135    | 0.10135    | 0.10135    |   0.0 |  0.04
Output  | 0.00020596 | 0.00020596 | 0.00020596 |   0.0 |  0.00
Modify  | 0.39452    | 0.39452    | 0.39452    |   0.0 |  0.17
Other   |            | 0.06159    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4138 ave        4138 max        4138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244172 ave      244172 max      244172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244172
Ave neighs/atom = 122.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 = 332.760419695037, Press = 0.43706535630865
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    113000  -8392.5965     -8392.5965     -8477.8839     -8477.8839      330.07125      330.07125      23562.066      23562.066     -1076.2054     -1076.2054    
    114000  -8387.5932     -8387.5932     -8474.1983     -8474.1983      335.17094      335.17094      23570.129      23570.129     -1030.2471     -1030.2471    
Loop time of 231.909 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.419 hours/ns, 4.312 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.34     | 231.34     | 231.34     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10291    | 0.10291    | 0.10291    |   0.0 |  0.04
Output  | 0.00016328 | 0.00016328 | 0.00016328 |   0.0 |  0.00
Modify  | 0.40254    | 0.40254    | 0.40254    |   0.0 |  0.17
Other   |            | 0.06223    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4134 ave        4134 max        4134 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243794 ave      243794 max      243794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.373 ns/day, 64.345 hours/ns, 4.317 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.08     | 231.08     | 231.08     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10229    | 0.10229    | 0.10229    |   0.0 |  0.04
Output  | 0.00016433 | 0.00016433 | 0.00016433 |   0.0 |  0.00
Modify  | 0.39826    | 0.39826    | 0.39826    |   0.0 |  0.17
Other   |            | 0.06156    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4132 ave        4132 max        4132 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243872 ave      243872 max      243872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.378 ns/day, 63.574 hours/ns, 4.369 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.31     | 228.31     | 228.31     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10127    | 0.10127    | 0.10127    |   0.0 |  0.04
Output  | 0.00016659 | 0.00016659 | 0.00016659 |   0.0 |  0.00
Modify  | 0.39153    | 0.39153    | 0.39153    |   0.0 |  0.17
Other   |            | 0.06162    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4150 ave        4150 max        4150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244854 ave      244854 max      244854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.383 ns/day, 62.601 hours/ns, 4.437 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 224.82     | 224.82     | 224.82     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10023    | 0.10023    | 0.10023    |   0.0 |  0.04
Output  | 0.00016646 | 0.00016646 | 0.00016646 |   0.0 |  0.00
Modify  | 0.37948    | 0.37948    | 0.37948    |   0.0 |  0.17
Other   |            | 0.06113    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4133 ave        4133 max        4133 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244986 ave      244986 max      244986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.373 ns/day, 64.313 hours/ns, 4.319 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.97     | 230.97     | 230.97     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10213    | 0.10213    | 0.10213    |   0.0 |  0.04
Output  | 0.00020028 | 0.00020028 | 0.00020028 |   0.0 |  0.00
Modify  | 0.39655    | 0.39655    | 0.39655    |   0.0 |  0.17
Other   |            | 0.06178    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4139 ave        4139 max        4139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244276 ave      244276 max      244276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.373 ns/day, 64.359 hours/ns, 4.316 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.13     | 231.13     | 231.13     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10309    | 0.10309    | 0.10309    |   0.0 |  0.04
Output  | 0.0001655  | 0.0001655  | 0.0001655  |   0.0 |  0.00
Modify  | 0.39989    | 0.39989    | 0.39989    |   0.0 |  0.17
Other   |            | 0.06207    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4129 ave        4129 max        4129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243532 ave      243532 max      243532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.373 ns/day, 64.426 hours/ns, 4.312 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.37     | 231.37     | 231.37     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10171    | 0.10171    | 0.10171    |   0.0 |  0.04
Output  | 0.00022193 | 0.00022193 | 0.00022193 |   0.0 |  0.00
Modify  | 0.39727    | 0.39727    | 0.39727    |   0.0 |  0.17
Other   |            | 0.06183    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4134 ave        4134 max        4134 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243772 ave      243772 max      243772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.374 ns/day, 64.252 hours/ns, 4.323 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.74     | 230.74     | 230.74     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10307    | 0.10307    | 0.10307    |   0.0 |  0.04
Output  | 0.00016606 | 0.00016606 | 0.00016606 |   0.0 |  0.00
Modify  | 0.39863    | 0.39863    | 0.39863    |   0.0 |  0.17
Other   |            | 0.06218    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4149 ave        4149 max        4149 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244142 ave      244142 max      244142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.375 ns/day, 64.053 hours/ns, 4.337 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.03     | 230.03     | 230.03     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10232    | 0.10232    | 0.10232    |   0.0 |  0.04
Output  | 0.00016635 | 0.00016635 | 0.00016635 |   0.0 |  0.00
Modify  | 0.39559    | 0.39559    | 0.39559    |   0.0 |  0.17
Other   |            | 0.06205    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4146 ave        4146 max        4146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244296 ave      244296 max      244296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.372 ns/day, 64.479 hours/ns, 4.308 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.56     | 231.56     | 231.56     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10211    | 0.10211    | 0.10211    |   0.0 |  0.04
Output  | 0.00016493 | 0.00016493 | 0.00016493 |   0.0 |  0.00
Modify  | 0.40234    | 0.40234    | 0.40234    |   0.0 |  0.17
Other   |            | 0.06242    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4133 ave        4133 max        4133 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244378 ave      244378 max      244378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.378 ns/day, 63.525 hours/ns, 4.373 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.14     | 228.14     | 228.14     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10138    | 0.10138    | 0.10138    |   0.0 |  0.04
Output  | 0.00016456 | 0.00016456 | 0.00016456 |   0.0 |  0.00
Modify  | 0.38881    | 0.38881    | 0.38881    |   0.0 |  0.17
Other   |            | 0.06158    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4142 ave        4142 max        4142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244452 ave      244452 max      244452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.379 ns/day, 63.312 hours/ns, 4.387 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.37     | 227.37     | 227.37     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10147    | 0.10147    | 0.10147    |   0.0 |  0.04
Output  | 0.00016471 | 0.00016471 | 0.00016471 |   0.0 |  0.00
Modify  | 0.38995    | 0.38995    | 0.38995    |   0.0 |  0.17
Other   |            | 0.06128    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4147 ave        4147 max        4147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243944 ave      243944 max      243944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.894 hours/ns, 4.348 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.46     | 229.46     | 229.46     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10163    | 0.10163    | 0.10163    |   0.0 |  0.04
Output  | 0.00016505 | 0.00016505 | 0.00016505 |   0.0 |  0.00
Modify  | 0.39573    | 0.39573    | 0.39573    |   0.0 |  0.17
Other   |            | 0.06277    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4137 ave        4137 max        4137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243626 ave      243626 max      243626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.380 ns/day, 63.083 hours/ns, 4.403 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.55     | 226.55     | 226.55     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1001     | 0.1001     | 0.1001     |   0.0 |  0.04
Output  | 0.00016298 | 0.00016298 | 0.00016298 |   0.0 |  0.00
Modify  | 0.38628    | 0.38628    | 0.38628    |   0.0 |  0.17
Other   |            | 0.06115    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4149 ave        4149 max        4149 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244264 ave      244264 max      244264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.374 ns/day, 64.223 hours/ns, 4.325 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.64     | 230.64     | 230.64     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10317    | 0.10317    | 0.10317    |   0.0 |  0.04
Output  | 0.00055683 | 0.00055683 | 0.00055683 |   0.0 |  0.00
Modify  | 0.40004    | 0.40004    | 0.40004    |   0.0 |  0.17
Other   |            | 0.06228    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4164 ave        4164 max        4164 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244566 ave      244566 max      244566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.373 ns/day, 64.310 hours/ns, 4.319 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.95     | 230.95     | 230.95     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10231    | 0.10231    | 0.10231    |   0.0 |  0.04
Output  | 0.0001663  | 0.0001663  | 0.0001663  |   0.0 |  0.00
Modify  | 0.40024    | 0.40024    | 0.40024    |   0.0 |  0.17
Other   |            | 0.06261    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4139 ave        4139 max        4139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244326 ave      244326 max      244326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.375 ns/day, 64.024 hours/ns, 4.339 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.92     | 229.92     | 229.92     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10186    | 0.10186    | 0.10186    |   0.0 |  0.04
Output  | 0.00016595 | 0.00016595 | 0.00016595 |   0.0 |  0.00
Modify  | 0.39596    | 0.39596    | 0.39596    |   0.0 |  0.17
Other   |            | 0.0624     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4149 ave        4149 max        4149 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244216 ave      244216 max      244216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244216
Ave neighs/atom = 122.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 = 332.747444907527, Press = 1.21436666625257
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    130000  -8391.2488     -8391.2488     -8478.9689     -8478.9689      339.48601      339.48601      23515.756      23515.756      2005.6573      2005.6573    
    131000  -8391.885      -8391.885      -8478.8757     -8478.8757      336.66285      336.66285      23504.289      23504.289      2963.4694      2963.4694    
Loop time of 231.185 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.218 hours/ns, 4.326 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.63     | 230.63     | 230.63     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10245    | 0.10245    | 0.10245    |   0.0 |  0.04
Output  | 0.00016439 | 0.00016439 | 0.00016439 |   0.0 |  0.00
Modify  | 0.39       | 0.39       | 0.39       |   0.0 |  0.17
Other   |            | 0.06144    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4155 ave        4155 max        4155 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244752 ave      244752 max      244752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.375 ns/day, 63.983 hours/ns, 4.341 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.78     | 229.78     | 229.78     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10161    | 0.10161    | 0.10161    |   0.0 |  0.04
Output  | 0.00016317 | 0.00016317 | 0.00016317 |   0.0 |  0.00
Modify  | 0.39459    | 0.39459    | 0.39459    |   0.0 |  0.17
Other   |            | 0.06174    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4148 ave        4148 max        4148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244924 ave      244924 max      244924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.377 ns/day, 63.687 hours/ns, 4.362 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.72     | 228.72     | 228.72     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10152    | 0.10152    | 0.10152    |   0.0 |  0.04
Output  | 0.00016585 | 0.00016585 | 0.00016585 |   0.0 |  0.00
Modify  | 0.39078    | 0.39078    | 0.39078    |   0.0 |  0.17
Other   |            | 0.06192    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4135 ave        4135 max        4135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244100 ave      244100 max      244100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.374 ns/day, 64.163 hours/ns, 4.329 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.43     | 230.43     | 230.43     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10219    | 0.10219    | 0.10219    |   0.0 |  0.04
Output  | 0.00017608 | 0.00017608 | 0.00017608 |   0.0 |  0.00
Modify  | 0.39576    | 0.39576    | 0.39576    |   0.0 |  0.17
Other   |            | 0.06185    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4147 ave        4147 max        4147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244136 ave      244136 max      244136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.373 ns/day, 64.380 hours/ns, 4.315 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.21     | 231.21     | 231.21     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1023     | 0.1023     | 0.1023     |   0.0 |  0.04
Output  | 0.00016347 | 0.00016347 | 0.00016347 |   0.0 |  0.00
Modify  | 0.39692    | 0.39692    | 0.39692    |   0.0 |  0.17
Other   |            | 0.06192    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4135 ave        4135 max        4135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243790 ave      243790 max      243790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.374 ns/day, 64.088 hours/ns, 4.334 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.15     | 230.15     | 230.15     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10249    | 0.10249    | 0.10249    |   0.0 |  0.04
Output  | 0.0001666  | 0.0001666  | 0.0001666  |   0.0 |  0.00
Modify  | 0.40051    | 0.40051    | 0.40051    |   0.0 |  0.17
Other   |            | 0.06285    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4139 ave        4139 max        4139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244452 ave      244452 max      244452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.372 ns/day, 64.582 hours/ns, 4.301 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.92     | 231.92     | 231.92     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10328    | 0.10328    | 0.10328    |   0.0 |  0.04
Output  | 0.00016186 | 0.00016186 | 0.00016186 |   0.0 |  0.00
Modify  | 0.40778    | 0.40778    | 0.40778    |   0.0 |  0.18
Other   |            | 0.06299    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4133 ave        4133 max        4133 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245202 ave      245202 max      245202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.372 ns/day, 64.529 hours/ns, 4.305 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.74     | 231.74     | 231.74     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10242    | 0.10242    | 0.10242    |   0.0 |  0.04
Output  | 0.00021222 | 0.00021222 | 0.00021222 |   0.0 |  0.00
Modify  | 0.40075    | 0.40075    | 0.40075    |   0.0 |  0.17
Other   |            | 0.06236    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4147 ave        4147 max        4147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244188 ave      244188 max      244188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244188
Ave neighs/atom = 122.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 = 332.815499343892, Press = 0.269432166181256
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    138000  -8392.7702     -8392.7702     -8477.4927     -8477.4927      327.88481      327.88481      23536.127      23536.127      705.29647      705.29647    
    139000  -8390.4406     -8390.4406     -8473.6831     -8473.6831      322.15714      322.15714      23554.081      23554.081      243.04249      243.04249    
Loop time of 232.099 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.372 ns/day, 64.472 hours/ns, 4.309 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.54     | 231.54     | 231.54     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10183    | 0.10183    | 0.10183    |   0.0 |  0.04
Output  | 0.0002224  | 0.0002224  | 0.0002224  |   0.0 |  0.00
Modify  | 0.39433    | 0.39433    | 0.39433    |   0.0 |  0.17
Other   |            | 0.06179    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4145 ave        4145 max        4145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244350 ave      244350 max      244350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.371 ns/day, 64.713 hours/ns, 4.292 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 232.4      | 232.4      | 232.4      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10302    | 0.10302    | 0.10302    |   0.0 |  0.04
Output  | 0.00016377 | 0.00016377 | 0.00016377 |   0.0 |  0.00
Modify  | 0.40255    | 0.40255    | 0.40255    |   0.0 |  0.17
Other   |            | 0.06263    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4146 ave        4146 max        4146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244220 ave      244220 max      244220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244220
Ave neighs/atom = 122.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 = 332.847802591105, Press = 0.41263405980468
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    140000  -8386.0225     -8386.0225     -8473.3889     -8473.3889      338.11684      338.11684      23560.561      23560.561      64.709963      64.709963    
    141000  -8391.1275     -8391.1275     -8476.0528     -8476.0528      328.66992      328.66992      23542.338      23542.338      605.79913      605.79913    
Loop time of 233.81 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.370 ns/day, 64.947 hours/ns, 4.277 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.24     | 233.24     | 233.24     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10368    | 0.10368    | 0.10368    |   0.0 |  0.04
Output  | 0.00020934 | 0.00020934 | 0.00020934 |   0.0 |  0.00
Modify  | 0.40064    | 0.40064    | 0.40064    |   0.0 |  0.17
Other   |            | 0.06277    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4149 ave        4149 max        4149 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244068 ave      244068 max      244068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.374 ns/day, 64.243 hours/ns, 4.324 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.72     | 230.72     | 230.72     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10179    | 0.10179    | 0.10179    |   0.0 |  0.04
Output  | 0.00024851 | 0.00024851 | 0.00024851 |   0.0 |  0.00
Modify  | 0.3909     | 0.3909     | 0.3909     |   0.0 |  0.17
Other   |            | 0.06218    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4164 ave        4164 max        4164 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244292 ave      244292 max      244292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.379 ns/day, 63.298 hours/ns, 4.388 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.33     | 227.33     | 227.33     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10037    | 0.10037    | 0.10037    |   0.0 |  0.04
Output  | 0.00016553 | 0.00016553 | 0.00016553 |   0.0 |  0.00
Modify  | 0.38039    | 0.38039    | 0.38039    |   0.0 |  0.17
Other   |            | 0.06089    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4152 ave        4152 max        4152 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244686 ave      244686 max      244686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.373 ns/day, 64.408 hours/ns, 4.313 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.31     | 231.31     | 231.31     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10161    | 0.10161    | 0.10161    |   0.0 |  0.04
Output  | 0.00020181 | 0.00020181 | 0.00020181 |   0.0 |  0.00
Modify  | 0.39624    | 0.39624    | 0.39624    |   0.0 |  0.17
Other   |            | 0.06195    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4142 ave        4142 max        4142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244242 ave      244242 max      244242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.373 ns/day, 64.413 hours/ns, 4.312 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.33     | 231.33     | 231.33     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10135    | 0.10135    | 0.10135    |   0.0 |  0.04
Output  | 0.0001647  | 0.0001647  | 0.0001647  |   0.0 |  0.00
Modify  | 0.39704    | 0.39704    | 0.39704    |   0.0 |  0.17
Other   |            | 0.06185    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4133 ave        4133 max        4133 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243664 ave      243664 max      243664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.375 ns/day, 64.081 hours/ns, 4.335 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 230.13     | 230.13     | 230.13     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10167    | 0.10167    | 0.10167    |   0.0 |  0.04
Output  | 0.00016838 | 0.00016838 | 0.00016838 |   0.0 |  0.00
Modify  | 0.39595    | 0.39595    | 0.39595    |   0.0 |  0.17
Other   |            | 0.06194    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4135 ave        4135 max        4135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243820 ave      243820 max      243820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.379 ns/day, 63.246 hours/ns, 4.392 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.14     | 227.14     | 227.14     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10022    | 0.10022    | 0.10022    |   0.0 |  0.04
Output  | 0.00016315 | 0.00016315 | 0.00016315 |   0.0 |  0.00
Modify  | 0.38413    | 0.38413    | 0.38413    |   0.0 |  0.17
Other   |            | 0.06113    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4154 ave        4154 max        4154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244070 ave      244070 max      244070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.390 ns/day, 61.505 hours/ns, 4.516 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    | 220.88     | 220.88     | 220.88     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10008    | 0.10008    | 0.10008    |   0.0 |  0.05
Output  | 0.00020437 | 0.00020437 | 0.00020437 |   0.0 |  0.00
Modify  | 0.37714    | 0.37714    | 0.37714    |   0.0 |  0.17
Other   |            | 0.06074    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4163 ave        4163 max        4163 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244096 ave      244096 max      244096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.379 ns/day, 63.374 hours/ns, 4.383 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.6      | 227.6      | 227.6      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10104    | 0.10104    | 0.10104    |   0.0 |  0.04
Output  | 0.00016331 | 0.00016331 | 0.00016331 |   0.0 |  0.00
Modify  | 0.38715    | 0.38715    | 0.38715    |   0.0 |  0.17
Other   |            | 0.0614     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4148 ave        4148 max        4148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244654 ave      244654 max      244654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.380 ns/day, 63.226 hours/ns, 4.393 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.06     | 227.06     | 227.06     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10112    | 0.10112    | 0.10112    |   0.0 |  0.04
Output  | 0.0001641  | 0.0001641  | 0.0001641  |   0.0 |  0.00
Modify  | 0.39019    | 0.39019    | 0.39019    |   0.0 |  0.17
Other   |            | 0.06172    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4145 ave        4145 max        4145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244232 ave      244232 max      244232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.375 ns/day, 63.921 hours/ns, 4.346 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.56     | 229.56     | 229.56     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10245    | 0.10245    | 0.10245    |   0.0 |  0.04
Output  | 0.0001648  | 0.0001648  | 0.0001648  |   0.0 |  0.00
Modify  | 0.39499    | 0.39499    | 0.39499    |   0.0 |  0.17
Other   |            | 0.06201    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4150 ave        4150 max        4150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243752 ave      243752 max      243752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.376 ns/day, 63.778 hours/ns, 4.355 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.04     | 229.04     | 229.04     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1017     | 0.1017     | 0.1017     |   0.0 |  0.04
Output  | 0.00016275 | 0.00016275 | 0.00016275 |   0.0 |  0.00
Modify  | 0.39366    | 0.39366    | 0.39366    |   0.0 |  0.17
Other   |            | 0.06201    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4143 ave        4143 max        4143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243944 ave      243944 max      243944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.375 ns/day, 63.920 hours/ns, 4.346 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.56     | 229.56     | 229.56     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10131    | 0.10131    | 0.10131    |   0.0 |  0.04
Output  | 0.00016444 | 0.00016444 | 0.00016444 |   0.0 |  0.00
Modify  | 0.39339    | 0.39339    | 0.39339    |   0.0 |  0.17
Other   |            | 0.06119    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4146 ave        4146 max        4146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244274 ave      244274 max      244274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.379 ns/day, 63.323 hours/ns, 4.387 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.41     | 227.41     | 227.41     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10045    | 0.10045    | 0.10045    |   0.0 |  0.04
Output  | 0.00017356 | 0.00017356 | 0.00017356 |   0.0 |  0.00
Modify  | 0.38846    | 0.38846    | 0.38846    |   0.0 |  0.17
Other   |            | 0.06145    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4145 ave        4145 max        4145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244120 ave      244120 max      244120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.377 ns/day, 63.584 hours/ns, 4.369 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.35     | 228.35     | 228.35     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10078    | 0.10078    | 0.10078    |   0.0 |  0.04
Output  | 0.00016198 | 0.00016198 | 0.00016198 |   0.0 |  0.00
Modify  | 0.38514    | 0.38514    | 0.38514    |   0.0 |  0.17
Other   |            | 0.06145    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4137 ave        4137 max        4137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244576 ave      244576 max      244576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.380 ns/day, 63.124 hours/ns, 4.401 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.7      | 226.7      | 226.7      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10027    | 0.10027    | 0.10027    |   0.0 |  0.04
Output  | 0.00016269 | 0.00016269 | 0.00016269 |   0.0 |  0.00
Modify  | 0.38554    | 0.38554    | 0.38554    |   0.0 |  0.17
Other   |            | 0.06162    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4137 ave        4137 max        4137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244372 ave      244372 max      244372 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.375 ns/day, 63.944 hours/ns, 4.344 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 229.64     | 229.64     | 229.64     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10216    | 0.10216    | 0.10216    |   0.0 |  0.04
Output  | 0.00016196 | 0.00016196 | 0.00016196 |   0.0 |  0.00
Modify  | 0.39194    | 0.39194    | 0.39194    |   0.0 |  0.17
Other   |            | 0.06146    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4159 ave        4159 max        4159 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244604 ave      244604 max      244604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.383 ns/day, 62.676 hours/ns, 4.432 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 225.09     | 225.09     | 225.09     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099332   | 0.099332   | 0.099332   |   0.0 |  0.04
Output  | 0.00016584 | 0.00016584 | 0.00016584 |   0.0 |  0.00
Modify  | 0.38049    | 0.38049    | 0.38049    |   0.0 |  0.17
Other   |            | 0.06082    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4135 ave        4135 max        4135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243608 ave      243608 max      243608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.387 ns/day, 62.069 hours/ns, 4.475 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 222.91     | 222.91     | 222.91     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098668   | 0.098668   | 0.098668   |   0.0 |  0.04
Output  | 0.00016476 | 0.00016476 | 0.00016476 |   0.0 |  0.00
Modify  | 0.37869    | 0.37869    | 0.37869    |   0.0 |  0.17
Other   |            | 0.06095    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4138 ave        4138 max        4138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       243590 ave      243590 max      243590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.380 ns/day, 63.147 hours/ns, 4.399 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 226.78     | 226.78     | 226.78     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099469   | 0.099469   | 0.099469   |   0.0 |  0.04
Output  | 0.00027371 | 0.00027371 | 0.00027371 |   0.0 |  0.00
Modify  | 0.38296    | 0.38296    | 0.38296    |   0.0 |  0.17
Other   |            | 0.06132    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4143 ave        4143 max        4143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244482 ave      244482 max      244482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.383 ns/day, 62.706 hours/ns, 4.430 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 225.19     | 225.19     | 225.19     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10027    | 0.10027    | 0.10027    |   0.0 |  0.04
Output  | 0.00022418 | 0.00022418 | 0.00022418 |   0.0 |  0.00
Modify  | 0.38451    | 0.38451    | 0.38451    |   0.0 |  0.17
Other   |            | 0.06098    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4147 ave        4147 max        4147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244106 ave      244106 max      244106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0