# 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 253.15*${_u_temperature}
variable temp_converted equal 253.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 253.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 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.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  "253.15 - 0.2"
variable      T_up  equal  "253.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  -8494.5846     -8494.5846     -8559.9963     -8559.9963      253.15         253.15         23173.474      23173.474      3014.9777      3014.9777    
      1000  -8432.6768     -8432.6768     -8495.0167     -8495.0167      241.26196      241.26196      23467.497      23467.497     -119.96236     -119.96236    
Loop time of 233.569 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 233.05     | 233.05     | 233.05     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099319   | 0.099319   | 0.099319   |   0.0 |  0.04
Output  | 0.00020955 | 0.00020955 | 0.00020955 |   0.0 |  0.00
Modify  | 0.3573     | 0.3573     | 0.3573     |   0.0 |  0.15
Other   |            | 0.0602     |            |       |  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  -8432.6768     -8432.6768     -8495.0167     -8495.0167      241.26196      241.26196      23467.497      23467.497     -119.96236     -119.96236    
      2000  -8428.7943     -8428.7943     -8495.6678     -8495.6678      258.80714      258.80714      23439.311      23439.311      2090.8589      2090.8589    
Loop time of 224.712 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.384 ns/day, 62.420 hours/ns, 4.450 timesteps/s
99.9% 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.2      | 224.2      | 224.2      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098885   | 0.098885   | 0.098885   |   0.0 |  0.04
Output  | 0.00021218 | 0.00021218 | 0.00021218 |   0.0 |  0.00
Modify  | 0.35627    | 0.35627    | 0.35627    |   0.0 |  0.16
Other   |            | 0.06065    |            |       |  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:       245292 ave      245292 max      245292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245292
Ave neighs/atom = 122.646
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -8428.7943     -8428.7943     -8495.6678     -8495.6678      258.80714      258.80714      23439.311      23439.311      2090.8589      2090.8589    
      3000  -8433.4256     -8433.4256     -8498.3593     -8498.3593      251.29997      251.29997      23484.727      23484.727     -2040.487      -2040.487     
Loop time of 227.905 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.379 ns/day, 63.307 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.38     | 227.38     | 227.38     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10122    | 0.10122    | 0.10122    |   0.0 |  0.04
Output  | 0.00020296 | 0.00020296 | 0.00020296 |   0.0 |  0.00
Modify  | 0.36438    | 0.36438    | 0.36438    |   0.0 |  0.16
Other   |            | 0.06145    |            |       |  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:       245742 ave      245742 max      245742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245742
Ave neighs/atom = 122.871
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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  -8433.4256     -8433.4256     -8498.3593     -8498.3593      251.29997      251.29997      23484.727      23484.727     -2040.487      -2040.487     
      4000  -8429.1859     -8429.1859     -8496.2095     -8496.2095      259.38829      259.38829      23456.762      23456.762      601.52257      601.52257    
Loop time of 229.964 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.879 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.44     | 229.44     | 229.44     |   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.00020369 | 0.00020369 | 0.00020369 |   0.0 |  0.00
Modify  | 0.36347    | 0.36347    | 0.36347    |   0.0 |  0.16
Other   |            | 0.06143    |            |       |  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:       244942 ave      244942 max      244942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244942
Ave neighs/atom = 122.471
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -8429.1859     -8429.1859     -8496.2095     -8496.2095      259.38829      259.38829      23456.762      23456.762      601.52257      601.52257    
      5000  -8432.3249     -8432.3249     -8497.8671     -8497.8671      253.655        253.655        23443.959      23443.959      1134.5039      1134.5039    
Loop time of 231.486 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.302 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.95     | 230.95     | 230.95     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10068    | 0.10068    | 0.10068    |   0.0 |  0.04
Output  | 0.00021196 | 0.00021196 | 0.00021196 |   0.0 |  0.00
Modify  | 0.37112    | 0.37112    | 0.37112    |   0.0 |  0.16
Other   |            | 0.06155    |            |       |  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:       245502 ave      245502 max      245502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245502
Ave neighs/atom = 122.751
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 250.869416233888, Press = -465.164461484365
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8432.3249     -8432.3249     -8497.8671     -8497.8671      253.655        253.655        23443.959      23443.959      1134.5039      1134.5039    
      6000  -8435.0227     -8435.0227     -8499.7257     -8499.7257      250.40739      250.40739      23458.354      23458.354     -659.29328     -659.29328    
Loop time of 229.308 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.76     | 228.76     | 228.76     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1009     | 0.1009     | 0.1009     |   0.0 |  0.04
Output  | 0.00016891 | 0.00016891 | 0.00016891 |   0.0 |  0.00
Modify  | 0.38538    | 0.38538    | 0.38538    |   0.0 |  0.17
Other   |            | 0.06072    |            |       |  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:       245710 ave      245710 max      245710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245710
Ave neighs/atom = 122.855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.824216409794, Press = -79.7231129843096
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8435.0227     -8435.0227     -8499.7257     -8499.7257      250.40739      250.40739      23458.354      23458.354     -659.29328     -659.29328    
      7000  -8430.3042     -8430.3042     -8496.2978     -8496.2978      255.40229      255.40229      23494.685      23494.685     -2079.1163     -2079.1163    
Loop time of 230.139 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 63.928 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.58     | 229.58     | 229.58     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10205    | 0.10205    | 0.10205    |   0.0 |  0.04
Output  | 0.00019883 | 0.00019883 | 0.00019883 |   0.0 |  0.00
Modify  | 0.394      | 0.394      | 0.394      |   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:           4125 ave        4125 max        4125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245250 ave      245250 max      245250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245250
Ave neighs/atom = 122.625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.139333940214, Press = 4.02548399612373
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8430.3042     -8430.3042     -8496.2978     -8496.2978      255.40229      255.40229      23494.685      23494.685     -2079.1163     -2079.1163    
      8000  -8433.7349     -8433.7349     -8497.5382     -8497.5382      246.92564      246.92564      23442.649      23442.649      1279.4118      1279.4118    
Loop time of 231.792 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.24     | 231.24     | 231.24     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10174    | 0.10174    | 0.10174    |   0.0 |  0.04
Output  | 0.00020561 | 0.00020561 | 0.00020561 |   0.0 |  0.00
Modify  | 0.38849    | 0.38849    | 0.38849    |   0.0 |  0.17
Other   |            | 0.06093    |            |       |  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:       244836 ave      244836 max      244836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244836
Ave neighs/atom = 122.418
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 251.869508590905, Press = -4.01099032101444
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8433.7349     -8433.7349     -8497.5382     -8497.5382      246.92564      246.92564      23442.649      23442.649      1279.4118      1279.4118    
      9000  -8430.0672     -8430.0672     -8495.5638     -8495.5638      253.47855      253.47855      23463.483      23463.483      377.75773      377.75773    
Loop time of 228.715 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.17     | 228.17     | 228.17     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10011    | 0.10011    | 0.10011    |   0.0 |  0.04
Output  | 0.00016434 | 0.00016434 | 0.00016434 |   0.0 |  0.00
Modify  | 0.38326    | 0.38326    | 0.38326    |   0.0 |  0.17
Other   |            | 0.06057    |            |       |  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:       245640 ave      245640 max      245640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 232.78     | 232.78     | 232.78     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10205    | 0.10205    | 0.10205    |   0.0 |  0.04
Output  | 0.00016611 | 0.00016611 | 0.00016611 |   0.0 |  0.00
Modify  | 0.39679    | 0.39679    | 0.39679    |   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:           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:       245326 ave      245326 max      245326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245326
Ave neighs/atom = 122.663
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.808569254663, Press = -12.7610734180954
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8429.2276     -8429.2276     -8495.7839     -8495.7839      257.57947      257.57947      23470.382      23470.382     -234.68737     -234.68737    
     11000  -8432.0378     -8432.0378     -8497.0826     -8497.0826      251.73007      251.73007      23485.635      23485.635     -1917.8356     -1917.8356    
Loop time of 231.205 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.224 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.65     | 230.65     | 230.65     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10162    | 0.10162    | 0.10162    |   0.0 |  0.04
Output  | 0.00016418 | 0.00016418 | 0.00016418 |   0.0 |  0.00
Modify  | 0.38873    | 0.38873    | 0.38873    |   0.0 |  0.17
Other   |            | 0.06116    |            |       |  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:       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 = 252.963450099407, Press = 3.14218999133529
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8432.0378     -8432.0378     -8497.0826     -8497.0826      251.73007      251.73007      23485.635      23485.635     -1917.8356     -1917.8356    
     12000  -8428.4439     -8428.4439     -8495.6826     -8495.6826      260.22056      260.22056      23418.316      23418.316      3664.0922      3664.0922    
Loop time of 231.756 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.377 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.2      | 231.2      | 231.2      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10206    | 0.10206    | 0.10206    |   0.0 |  0.04
Output  | 0.00016392 | 0.00016392 | 0.00016392 |   0.0 |  0.00
Modify  | 0.39404    | 0.39404    | 0.39404    |   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:           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:       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 = 253.118192451212, Press = -0.383478200376724
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -8428.4439     -8428.4439     -8495.6826     -8495.6826      260.22056      260.22056      23418.316      23418.316      3664.0922      3664.0922    
     13000  -8430.6143     -8430.6143     -8496.5121     -8496.5121      255.03162      255.03162      23465.114      23465.114     -245.6219      -245.6219     
Loop time of 233.149 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 232.59     | 232.59     | 232.59     |   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.00016714 | 0.00016714 | 0.00016714 |   0.0 |  0.00
Modify  | 0.39878    | 0.39878    | 0.39878    |   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:           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:       246162 ave      246162 max      246162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 246162
Ave neighs/atom = 123.081
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.966787181972, Press = -10.3584147208382
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8430.6143     -8430.6143     -8496.5121     -8496.5121      255.03162      255.03162      23465.114      23465.114     -245.6219      -245.6219     
     14000  -8435.0775     -8435.0775     -8497.5246     -8497.5246      241.67681      241.67681      23476.854      23476.854     -1467.7922     -1467.7922    
Loop time of 231.453 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.292 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.9      | 230.9      | 230.9      |   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.00045459 | 0.00045459 | 0.00045459 |   0.0 |  0.00
Modify  | 0.39381    | 0.39381    | 0.39381    |   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:           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:       245408 ave      245408 max      245408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245408
Ave neighs/atom = 122.704
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.879094446004, Press = -4.48648537811476
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8435.0775     -8435.0775     -8497.5246     -8497.5246      241.67681      241.67681      23476.854      23476.854     -1467.7922     -1467.7922    
     15000  -8429.6834     -8429.6834     -8497.3416     -8497.3416      261.84425      261.84425      23450.672      23450.672      733.46939      733.46939    
Loop time of 232.605 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.371 ns/day, 64.613 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.04     | 232.04     | 232.04     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10282    | 0.10282    | 0.10282    |   0.0 |  0.04
Output  | 0.00019927 | 0.00019927 | 0.00019927 |   0.0 |  0.00
Modify  | 0.3996     | 0.3996     | 0.3996     |   0.0 |  0.17
Other   |            | 0.06177    |            |       |  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:       245054 ave      245054 max      245054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245054
Ave neighs/atom = 122.527
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.718011824097, Press = 2.69858457141242
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8429.6834     -8429.6834     -8497.3416     -8497.3416      261.84425      261.84425      23450.672      23450.672      733.46939      733.46939    
     16000  -8432.0141     -8432.0141     -8496.2087     -8496.2087      248.43999      248.43999      23435.66       23435.66       2110.6448      2110.6448    
Loop time of 232.807 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.371 ns/day, 64.669 hours/ns, 4.295 timesteps/s
99.9% 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.25     | 232.25     | 232.25     |   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.000203   | 0.000203   | 0.000203   |   0.0 |  0.00
Modify  | 0.39627    | 0.39627    | 0.39627    |   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:           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:       245598 ave      245598 max      245598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245598
Ave neighs/atom = 122.799
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.644368769349, Press = -5.4786713125577
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8432.0141     -8432.0141     -8496.2087     -8496.2087      248.43999      248.43999      23435.66       23435.66       2110.6448      2110.6448    
     17000  -8434.219      -8434.219      -8499.3607     -8499.3607      252.10509      252.10509      23479.491      23479.491     -2084.7627     -2084.7627    
Loop time of 233.963 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.369 ns/day, 64.990 hours/ns, 4.274 timesteps/s
99.9% 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.4      | 233.4      | 233.4      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10329    | 0.10329    | 0.10329    |   0.0 |  0.04
Output  | 0.00020396 | 0.00020396 | 0.00020396 |   0.0 |  0.00
Modify  | 0.39684    | 0.39684    | 0.39684    |   0.0 |  0.17
Other   |            | 0.06212    |            |       |  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:       245888 ave      245888 max      245888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245888
Ave neighs/atom = 122.944
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.70630438804, Press = -4.05967826321084
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8434.219      -8434.219      -8499.3607     -8499.3607      252.10509      252.10509      23479.491      23479.491     -2084.7627     -2084.7627    
     18000  -8430.1304     -8430.1304     -8497.0764     -8497.0764      259.08796      259.08796      23453.144      23453.144      654.68057      654.68057    
Loop time of 232.569 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.372 ns/day, 64.602 hours/ns, 4.300 timesteps/s
99.9% 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.01     | 232.01     | 232.01     |   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.00019939 | 0.00019939 | 0.00019939 |   0.0 |  0.00
Modify  | 0.3948     | 0.3948     | 0.3948     |   0.0 |  0.17
Other   |            | 0.06138    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4127 ave        4127 max        4127 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245048 ave      245048 max      245048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245048
Ave neighs/atom = 122.524
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.626990100884, Press = -1.09369615941949
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8430.1304     -8430.1304     -8497.0764     -8497.0764      259.08796      259.08796      23453.144      23453.144      654.68057      654.68057    
     19000  -8432.7322     -8432.7322     -8496.2318     -8496.2318      245.74974      245.74974      23444.904      23444.904      1410.391       1410.391     
Loop time of 232.382 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.82     | 231.82     | 231.82     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10197    | 0.10197    | 0.10197    |   0.0 |  0.04
Output  | 0.00028531 | 0.00028531 | 0.00028531 |   0.0 |  0.00
Modify  | 0.39737    | 0.39737    | 0.39737    |   0.0 |  0.17
Other   |            | 0.06216    |            |       |  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:       245536 ave      245536 max      245536 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245536
Ave neighs/atom = 122.768
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.571809865323, Press = -2.81143463313686
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8432.7322     -8432.7322     -8496.2318     -8496.2318      245.74974      245.74974      23444.904      23444.904      1410.391       1410.391     
     20000  -8429.3853     -8429.3853     -8495.7947     -8495.7947      257.01108      257.01108      23498.177      23498.177     -2383.1949     -2383.1949    
Loop time of 233.394 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 232.84     | 232.84     | 232.84     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10154    | 0.10154    | 0.10154    |   0.0 |  0.04
Output  | 0.00016203 | 0.00016203 | 0.00016203 |   0.0 |  0.00
Modify  | 0.39488    | 0.39488    | 0.39488    |   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:           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:       245804 ave      245804 max      245804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245804
Ave neighs/atom = 122.902
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.659817757562, Press = -4.53714717371293
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8429.3853     -8429.3853     -8495.7947     -8495.7947      257.01108      257.01108      23498.177      23498.177     -2383.1949     -2383.1949    
     21000  -8431.7673     -8431.7673     -8496.0563     -8496.0563      248.80501      248.80501      23449.736      23449.736      1078.2935      1078.2935    
Loop time of 232.912 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 232.35     | 232.35     | 232.35     |   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.00016415 | 0.00016415 | 0.00016415 |   0.0 |  0.00
Modify  | 0.39569    | 0.39569    | 0.39569    |   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:           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:       244834 ave      244834 max      244834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244834
Ave neighs/atom = 122.417
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.781845491488, Press = 1.33172684657625
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8431.7673     -8431.7673     -8496.0563     -8496.0563      248.80501      248.80501      23449.736      23449.736      1078.2935      1078.2935    
     22000  -8430.1533     -8430.1533     -8494.7533     -8494.7533      250.00867      250.00867      23426.09       23426.09       3095.0269      3095.0269    
Loop time of 232.005 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.372 ns/day, 64.446 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.45     | 231.45     | 231.45     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10255    | 0.10255    | 0.10255    |   0.0 |  0.04
Output  | 0.0001632  | 0.0001632  | 0.0001632  |   0.0 |  0.00
Modify  | 0.39466    | 0.39466    | 0.39466    |   0.0 |  0.17
Other   |            | 0.06157    |            |       |  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:       245488 ave      245488 max      245488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245488
Ave neighs/atom = 122.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 = 252.929515181591, Press = -4.77655144133072
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8430.1533     -8430.1533     -8494.7533     -8494.7533      250.00867      250.00867      23426.09       23426.09       3095.0269      3095.0269    
     23000  -8431.399      -8431.399      -8496.3342     -8496.3342      251.30587      251.30587      23479.653      23479.653     -1224.9179     -1224.9179    
Loop time of 229.813 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.837 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.26     | 229.26     | 229.26     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10247    | 0.10247    | 0.10247    |   0.0 |  0.04
Output  | 0.00016379 | 0.00016379 | 0.00016379 |   0.0 |  0.00
Modify  | 0.38924    | 0.38924    | 0.38924    |   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:           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:       246024 ave      246024 max      246024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 246024
Ave neighs/atom = 123.012
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.013337856481, Press = -2.81797467451943
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8431.399      -8431.399      -8496.3342     -8496.3342      251.30587      251.30587      23479.653      23479.653     -1224.9179     -1224.9179    
     24000  -8434.1806     -8434.1806     -8497.0649     -8497.0649      243.36845      243.36845      23455.031      23455.031      273.37954      273.37954    
Loop time of 231.542 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.317 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.99     | 230.99     | 230.99     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10177    | 0.10177    | 0.10177    |   0.0 |  0.04
Output  | 0.00026468 | 0.00026468 | 0.00026468 |   0.0 |  0.00
Modify  | 0.39181    | 0.39181    | 0.39181    |   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:           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:       245074 ave      245074 max      245074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245074
Ave neighs/atom = 122.537
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.029400926317, Press = 0.324556513178096
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8434.1806     -8434.1806     -8497.0649     -8497.0649      243.36845      243.36845      23455.031      23455.031      273.37954      273.37954    
     25000  -8430.5853     -8430.5853     -8496.3431     -8496.3431      254.4893       254.4893       23458.114      23458.114      277.23948      277.23948    
Loop time of 229.887 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.857 hours/ns, 4.350 timesteps/s
99.9% 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.33     | 229.33     | 229.33     |   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.00019911 | 0.00019911 | 0.00019911 |   0.0 |  0.00
Modify  | 0.39012    | 0.39012    | 0.39012    |   0.0 |  0.17
Other   |            | 0.06092    |            |       |  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:       245652 ave      245652 max      245652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245652
Ave neighs/atom = 122.826
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.94263888803, Press = -2.5828487296474
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8430.5853     -8430.5853     -8496.3431     -8496.3431      254.4893       254.4893       23458.114      23458.114      277.23948      277.23948    
     26000  -8431.7652     -8431.7652     -8494.9418     -8494.9418      244.49975      244.49975      23458.743      23458.743      683.97306      683.97306    
Loop time of 230.527 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.97     | 229.97     | 229.97     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10092    | 0.10092    | 0.10092    |   0.0 |  0.04
Output  | 0.00016288 | 0.00016288 | 0.00016288 |   0.0 |  0.00
Modify  | 0.39048    | 0.39048    | 0.39048    |   0.0 |  0.17
Other   |            | 0.06149    |            |       |  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:       245588 ave      245588 max      245588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245588
Ave neighs/atom = 122.794
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.006454740606, Press = -1.77601340452965
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8431.7652     -8431.7652     -8494.9418     -8494.9418      244.49975      244.49975      23458.743      23458.743      683.97306      683.97306    
     27000  -8430.4618     -8430.4618     -8494.5943     -8494.5943      248.1994       248.1994       23470.791      23470.791      3.686936       3.686936     
Loop time of 227.658 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.380 ns/day, 63.238 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.11     | 227.11     | 227.11     |   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.00016147 | 0.00016147 | 0.00016147 |   0.0 |  0.00
Modify  | 0.3831     | 0.3831     | 0.3831     |   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:           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:       245414 ave      245414 max      245414 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245414
Ave neighs/atom = 122.707
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.956658888533, Press = -0.734137448029702
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8430.4618     -8430.4618     -8494.5943     -8494.5943      248.1994       248.1994       23470.791      23470.791      3.686936       3.686936     
     28000  -8434.1776     -8434.1776     -8500.4077     -8500.4077      256.31718      256.31718      23447.154      23447.154      196.16504      196.16504    
Loop time of 227.436 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.380 ns/day, 63.177 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.9      | 226.9      | 226.9      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10028    | 0.10028    | 0.10028    |   0.0 |  0.04
Output  | 0.00016495 | 0.00016495 | 0.00016495 |   0.0 |  0.00
Modify  | 0.37958    | 0.37958    | 0.37958    |   0.0 |  0.17
Other   |            | 0.06055    |            |       |  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:       245244 ave      245244 max      245244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245244
Ave neighs/atom = 122.622
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.880452440487, Press = -2.59661177151258
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8434.1776     -8434.1776     -8500.4077     -8500.4077      256.31718      256.31718      23447.154      23447.154      196.16504      196.16504    
     29000  -8429.226      -8429.226      -8496.122      -8496.122       258.89446      258.89446      23479.576      23479.576     -1054.2616     -1054.2616    
Loop time of 230.691 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.1021     | 0.1021     | 0.1021     |   0.0 |  0.04
Output  | 0.00016299 | 0.00016299 | 0.00016299 |   0.0 |  0.00
Modify  | 0.39251    | 0.39251    | 0.39251    |   0.0 |  0.17
Other   |            | 0.06208    |            |       |  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:       245644 ave      245644 max      245644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245644
Ave neighs/atom = 122.822
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.865345281606, Press = -0.701395513749019
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8429.226      -8429.226      -8496.122      -8496.122       258.89446      258.89446      23479.576      23479.576     -1054.2616     -1054.2616    
     30000  -8433.4975     -8433.4975     -8499.6007     -8499.6007      255.82618      255.82618      23457.376      23457.376     -335.78767     -335.78767    
Loop time of 228.931 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.592 hours/ns, 4.368 timesteps/s
99.9% 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.38     | 228.38     | 228.38     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1014     | 0.1014     | 0.1014     |   0.0 |  0.04
Output  | 0.00016487 | 0.00016487 | 0.00016487 |   0.0 |  0.00
Modify  | 0.38754    | 0.38754    | 0.38754    |   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:           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:       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 = 252.889528960399, Press = -1.76611492915089
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8433.4975     -8433.4975     -8499.6007     -8499.6007      255.82618      255.82618      23457.376      23457.376     -335.78767     -335.78767    
     31000  -8431.4516     -8431.4516     -8496.3627     -8496.3627      251.21286      251.21286      23458.294      23458.294      497.81123      497.81123    
Loop time of 231.25 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.236 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.69     | 230.69     | 230.69     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10321    | 0.10321    | 0.10321    |   0.0 |  0.04
Output  | 0.00016431 | 0.00016431 | 0.00016431 |   0.0 |  0.00
Modify  | 0.3951     | 0.3951     | 0.3951     |   0.0 |  0.17
Other   |            | 0.06151    |            |       |  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:       245362 ave      245362 max      245362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245362
Ave neighs/atom = 122.681
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.921674632566, Press = -2.0754144086244
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8431.4516     -8431.4516     -8496.3627     -8496.3627      251.21286      251.21286      23458.294      23458.294      497.81123      497.81123    
     32000  -8431.9491     -8431.9491     -8497.1679     -8497.1679      252.40358      252.40358      23450.621      23450.621      723.17747      723.17747    
Loop time of 231.009 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.169 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.45     | 230.45     | 230.45     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10103    | 0.10103    | 0.10103    |   0.0 |  0.04
Output  | 0.00016359 | 0.00016359 | 0.00016359 |   0.0 |  0.00
Modify  | 0.3929     | 0.3929     | 0.3929     |   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:           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:       245404 ave      245404 max      245404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245404
Ave neighs/atom = 122.702
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.869848355872, Press = -1.73830714470221
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8431.9491     -8431.9491     -8497.1679     -8497.1679      252.40358      252.40358      23450.621      23450.621      723.17747      723.17747    
     33000  -8433.303      -8433.303      -8498.012      -8498.012       250.43026      250.43026      23478.594      23478.594     -1711.0147     -1711.0147    
Loop time of 229.213 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.670 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.67     | 228.67     | 228.67     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10028    | 0.10028    | 0.10028    |   0.0 |  0.04
Output  | 0.00023396 | 0.00023396 | 0.00023396 |   0.0 |  0.00
Modify  | 0.38548    | 0.38548    | 0.38548    |   0.0 |  0.17
Other   |            | 0.06083    |            |       |  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:       245448 ave      245448 max      245448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245448
Ave neighs/atom = 122.724
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.858521062057, Press = -1.80132470176986
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8433.303      -8433.303      -8498.012      -8498.012       250.43026      250.43026      23478.594      23478.594     -1711.0147     -1711.0147    
     34000  -8430.6595     -8430.6595     -8495.7924     -8495.7924      252.07135      252.07135      23465.286      23465.286      4.2129075      4.2129075    
Loop time of 227.816 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 227.27     | 227.27     | 227.27     |   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.00016253 | 0.00016253 | 0.00016253 |   0.0 |  0.00
Modify  | 0.38488    | 0.38488    | 0.38488    |   0.0 |  0.17
Other   |            | 0.06102    |            |       |  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:       245018 ave      245018 max      245018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245018
Ave neighs/atom = 122.509
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.854428189189, Press = -0.770379613149311
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8430.6595     -8430.6595     -8495.7924     -8495.7924      252.07135      252.07135      23465.286      23465.286      4.2129075      4.2129075    
     35000  -8434.2438     -8434.2438     -8500.3393     -8500.3393      255.79664      255.79664      23442.73       23442.73       471.73293      471.73293    
Loop time of 231.529 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.10204    | 0.10204    | 0.10204    |   0.0 |  0.04
Output  | 0.00016456 | 0.00016456 | 0.00016456 |   0.0 |  0.00
Modify  | 0.3932     | 0.3932     | 0.3932     |   0.0 |  0.17
Other   |            | 0.06149    |            |       |  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:       245386 ave      245386 max      245386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245386
Ave neighs/atom = 122.693
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.773091433673, Press = -2.20930785825415
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8434.2438     -8434.2438     -8500.3393     -8500.3393      255.79664      255.79664      23442.73       23442.73       471.73293      471.73293    
     36000  -8430.7171     -8430.7171     -8495.809      -8495.809       251.91256      251.91256      23481.97       23481.97      -1084.103      -1084.103     
Loop time of 227.821 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.379 ns/day, 63.283 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.27     | 227.27     | 227.27     |   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.00016442 | 0.00016442 | 0.00016442 |   0.0 |  0.00
Modify  | 0.3844     | 0.3844     | 0.3844     |   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:           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:       245668 ave      245668 max      245668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245668
Ave neighs/atom = 122.834
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.752629843664, Press = -2.53513726444389
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8430.7171     -8430.7171     -8495.809      -8495.809       251.91256      251.91256      23481.97       23481.97      -1084.103      -1084.103     
     37000  -8433.6146     -8433.6146     -8496.122      -8496.122       241.91001      241.91001      23446.14       23446.14       1137.4542      1137.4542    
Loop time of 228.857 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.378 ns/day, 63.571 hours/ns, 4.370 timesteps/s
99.9% 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.10019    | 0.10019    | 0.10019    |   0.0 |  0.04
Output  | 0.00016774 | 0.00016774 | 0.00016774 |   0.0 |  0.00
Modify  | 0.38383    | 0.38383    | 0.38383    |   0.0 |  0.17
Other   |            | 0.06061    |            |       |  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:       244814 ave      244814 max      244814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244814
Ave neighs/atom = 122.407
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.704366306815, Press = 0.115472691267686
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8433.6146     -8433.6146     -8496.122      -8496.122       241.91001      241.91001      23446.14       23446.14       1137.4542      1137.4542    
     38000  -8430.8744     -8430.8744     -8496.0862     -8496.0862      252.37621      252.37621      23463.313      23463.313     -10.867942     -10.867942    
Loop time of 231.172 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.214 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.62     | 230.62     | 230.62     |   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.00016529 | 0.00016529 | 0.00016529 |   0.0 |  0.00
Modify  | 0.38905    | 0.38905    | 0.38905    |   0.0 |  0.17
Other   |            | 0.06123    |            |       |  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:       245496 ave      245496 max      245496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245496
Ave neighs/atom = 122.748
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.690229744296, Press = -2.34742155034741
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8430.8744     -8430.8744     -8496.0862     -8496.0862      252.37621      252.37621      23463.313      23463.313     -10.867942     -10.867942    
     39000  -8433.6432     -8433.6432     -8496.9174     -8496.9174      244.87802      244.87802      23471.422      23471.422     -961.32277     -961.32277    
Loop time of 233.347 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 232.78     | 232.78     | 232.78     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10335    | 0.10335    | 0.10335    |   0.0 |  0.04
Output  | 0.00016914 | 0.00016914 | 0.00016914 |   0.0 |  0.00
Modify  | 0.39767    | 0.39767    | 0.39767    |   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:           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:       245284 ave      245284 max      245284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245284
Ave neighs/atom = 122.642
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.630639794324, Press = -0.716183017395992
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8433.6432     -8433.6432     -8496.9174     -8496.9174      244.87802      244.87802      23471.422      23471.422     -961.32277     -961.32277    
     40000  -8430.1325     -8430.1325     -8496.115      -8496.115       255.35915      255.35915      23418.232      23418.232      3590.2663      3590.2663    
Loop time of 236.161 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.366 ns/day, 65.600 hours/ns, 4.234 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    | 235.6      | 235.6      | 235.6      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10304    | 0.10304    | 0.10304    |   0.0 |  0.04
Output  | 0.00022628 | 0.00022628 | 0.00022628 |   0.0 |  0.00
Modify  | 0.39956    | 0.39956    | 0.39956    |   0.0 |  0.17
Other   |            | 0.06217    |            |       |  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:       245140 ave      245140 max      245140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245140
Ave neighs/atom = 122.57
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.580307778612, Press = -1.16846445925292
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8430.1325     -8430.1325     -8496.115      -8496.115       255.35915      255.35915      23418.232      23418.232      3590.2663      3590.2663    
     41000  -8430.5241     -8430.5241     -8496.8353     -8496.8353      256.63129      256.63129      23491.951      23491.951     -2151.5971     -2151.5971    
Loop time of 232.325 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.76     | 231.76     | 231.76     |   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.00016511 | 0.00016511 | 0.00016511 |   0.0 |  0.00
Modify  | 0.39474    | 0.39474    | 0.39474    |   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:           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:       246164 ave      246164 max      246164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 246164
Ave neighs/atom = 123.082
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.576711069983, Press = -2.33385610242671
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8430.5241     -8430.5241     -8496.8353     -8496.8353      256.63129      256.63129      23491.951      23491.951     -2151.5971     -2151.5971    
     42000  -8430.5879     -8430.5879     -8495.0598     -8495.0598      249.51294      249.51294      23453.801      23453.801      1147.5561      1147.5561    
Loop time of 231.23 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.231 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.67     | 230.67     | 230.67     |   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.0001646  | 0.0001646  | 0.0001646  |   0.0 |  0.00
Modify  | 0.39237    | 0.39237    | 0.39237    |   0.0 |  0.17
Other   |            | 0.06157    |            |       |  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:       244692 ave      244692 max      244692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244692
Ave neighs/atom = 122.346
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.679432140098, Press = 0.28916471261625
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8430.5879     -8430.5879     -8495.0598     -8495.0598      249.51294      249.51294      23453.801      23453.801      1147.5561      1147.5561    
     43000  -8429.8809     -8429.8809     -8496.6187     -8496.6187      258.28238      258.28238      23448.434      23448.434      1207.7732      1207.7732    
Loop time of 230.539 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 64.039 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.99     | 229.99     | 229.99     |   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.00023386 | 0.00023386 | 0.00023386 |   0.0 |  0.00
Modify  | 0.39033    | 0.39033    | 0.39033    |   0.0 |  0.17
Other   |            | 0.06147    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4126 ave        4126 max        4126 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245588 ave      245588 max      245588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245588
Ave neighs/atom = 122.794
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.692848263827, Press = -2.37743587623472
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8429.8809     -8429.8809     -8496.6187     -8496.6187      258.28238      258.28238      23448.434      23448.434      1207.7732      1207.7732    
     44000  -8430.7367     -8430.7367     -8496.397      -8496.397       254.11184      254.11184      23477.306      23477.306     -959.98931     -959.98931    
Loop time of 231.328 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.258 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.77     | 230.77     | 230.77     |   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.00016409 | 0.00016409 | 0.00016409 |   0.0 |  0.00
Modify  | 0.39404    | 0.39404    | 0.39404    |   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:           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:       245586 ave      245586 max      245586 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245586
Ave neighs/atom = 122.793
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.766052814949, Press = -2.22873447196853
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8430.7367     -8430.7367     -8496.397      -8496.397       254.11184      254.11184      23477.306      23477.306     -959.98931     -959.98931    
     45000  -8431.3397     -8431.3397     -8497.0108     -8497.0108      254.15392      254.15392      23471.271      23471.271     -803.0043      -803.0043     
Loop time of 231.448 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.291 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.89     | 230.89     | 230.89     |   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.00016456 | 0.00016456 | 0.00016456 |   0.0 |  0.00
Modify  | 0.39591    | 0.39591    | 0.39591    |   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:           4125 ave        4125 max        4125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244966 ave      244966 max      244966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244966
Ave neighs/atom = 122.483
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.755766957592, Press = -0.387865846801076
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8431.3397     -8431.3397     -8497.0108     -8497.0108      254.15392      254.15392      23471.271      23471.271     -803.0043      -803.0043     
     46000  -8431.8364     -8431.8364     -8496.7797     -8496.7797      251.33755      251.33755      23456.859      23456.859      356.4771       356.4771     
Loop time of 229.314 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 228.76     | 228.76     | 228.76     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10097    | 0.10097    | 0.10097    |   0.0 |  0.04
Output  | 0.00021124 | 0.00021124 | 0.00021124 |   0.0 |  0.00
Modify  | 0.38807    | 0.38807    | 0.38807    |   0.0 |  0.17
Other   |            | 0.06232    |            |       |  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:       245234 ave      245234 max      245234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245234
Ave neighs/atom = 122.617
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.760464842455, Press = -0.880833719040999
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8431.8364     -8431.8364     -8496.7797     -8496.7797      251.33755      251.33755      23456.859      23456.859      356.4771       356.4771     
     47000  -8427.4052     -8427.4052     -8494.1599     -8494.1599      258.34741      258.34741      23477.357      23477.357     -310.61378     -310.61378    
Loop time of 229.842 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.845 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.29     | 229.29     | 229.29     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10188    | 0.10188    | 0.10188    |   0.0 |  0.04
Output  | 0.00020619 | 0.00020619 | 0.00020619 |   0.0 |  0.00
Modify  | 0.38809    | 0.38809    | 0.38809    |   0.0 |  0.17
Other   |            | 0.0606     |            |       |  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:       245532 ave      245532 max      245532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245532
Ave neighs/atom = 122.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 = 252.820617698144, Press = -1.61515026259664
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8427.4052     -8427.4052     -8494.1599     -8494.1599      258.34741      258.34741      23477.357      23477.357     -310.61378     -310.61378    
     48000  -8431.2533     -8431.2533     -8494.9993     -8494.9993      246.7034       246.7034       23477.937      23477.937     -766.32068     -766.32068    
Loop time of 229.979 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.376 ns/day, 63.883 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.43     | 229.43     | 229.43     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10075    | 0.10075    | 0.10075    |   0.0 |  0.04
Output  | 0.0001636  | 0.0001636  | 0.0001636  |   0.0 |  0.00
Modify  | 0.38658    | 0.38658    | 0.38658    |   0.0 |  0.17
Other   |            | 0.061      |            |       |  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:       245066 ave      245066 max      245066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245066
Ave neighs/atom = 122.533
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.83539167528, Press = -0.881658353278437
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8431.2533     -8431.2533     -8494.9993     -8494.9993      246.7034       246.7034       23477.937      23477.937     -766.32068     -766.32068    
     49000  -8429.5705     -8429.5705     -8495.0024     -8495.0024      253.22819      253.22819      23423.133      23423.133      3526.5757      3526.5757    
Loop time of 232.711 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 232.15     | 232.15     | 232.15     |   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.00024889 | 0.00024889 | 0.00024889 |   0.0 |  0.00
Modify  | 0.39427    | 0.39427    | 0.39427    |   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:           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:       245044 ave      245044 max      245044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245044
Ave neighs/atom = 122.522
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.84785411518, Press = -1.50714381948199
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8429.5705     -8429.5705     -8495.0024     -8495.0024      253.22819      253.22819      23423.133      23423.133      3526.5757      3526.5757    
     50000  -8432.3027     -8432.3027     -8497.9652     -8497.9652      254.12058      254.12058      23503.382      23503.382     -3277.7322     -3277.7322    
Loop time of 230.99 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.164 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.44     | 230.44     | 230.44     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10124    | 0.10124    | 0.10124    |   0.0 |  0.04
Output  | 0.00016559 | 0.00016559 | 0.00016559 |   0.0 |  0.00
Modify  | 0.39189    | 0.39189    | 0.39189    |   0.0 |  0.17
Other   |            | 0.06071    |            |       |  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:       246056 ave      246056 max      246056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 246056
Ave neighs/atom = 123.028
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.837848612, Press = -2.02428395119385
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8432.3027     -8432.3027     -8497.9652     -8497.9652      254.12058      254.12058      23503.382      23503.382     -3277.7322     -3277.7322    
     51000  -8431.4201     -8431.4201     -8497.823      -8497.823       256.9862       256.9862       23463.456      23463.456     -397.22721     -397.22721    
Loop time of 231.577 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.327 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.10211    | 0.10211    | 0.10211    |   0.0 |  0.04
Output  | 0.00016398 | 0.00016398 | 0.00016398 |   0.0 |  0.00
Modify  | 0.39415    | 0.39415    | 0.39415    |   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:           4126 ave        4126 max        4126 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244498 ave      244498 max      244498 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244498
Ave neighs/atom = 122.249
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.843527747656, Press = -0.299775416226272
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8431.4201     -8431.4201     -8497.823      -8497.823       256.9862       256.9862       23463.456      23463.456     -397.22721     -397.22721    
     52000  -8432.6044     -8432.6044     -8497.5224     -8497.5224      251.23926      251.23926      23449.042      23449.042      660.60317      660.60317    
Loop time of 230.138 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 63.927 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.58     | 229.58     | 229.58     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10142    | 0.10142    | 0.10142    |   0.0 |  0.04
Output  | 0.00046406 | 0.00046406 | 0.00046406 |   0.0 |  0.00
Modify  | 0.39205    | 0.39205    | 0.39205    |   0.0 |  0.17
Other   |            | 0.06134    |            |       |  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:       245242 ave      245242 max      245242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245242
Ave neighs/atom = 122.621
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.801254353691, Press = -1.19107979811274
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8432.6044     -8432.6044     -8497.5224     -8497.5224      251.23926      251.23926      23449.042      23449.042      660.60317      660.60317    
     53000  -8431.049      -8431.049      -8496.0297     -8496.0297      251.48222      251.48222      23466.345      23466.345     -163.81494     -163.81494    
Loop time of 231.785 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 231.22     | 231.22     | 231.22     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1027     | 0.1027     | 0.1027     |   0.0 |  0.04
Output  | 0.00016314 | 0.00016314 | 0.00016314 |   0.0 |  0.00
Modify  | 0.39597    | 0.39597    | 0.39597    |   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:           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:       245650 ave      245650 max      245650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245650
Ave neighs/atom = 122.825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.797662006311, Press = -0.764366359584681
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8431.049      -8431.049      -8496.0297     -8496.0297      251.48222      251.48222      23466.345      23466.345     -163.81494     -163.81494    
     54000  -8430.2603     -8430.2603     -8496.805      -8496.805       257.53484      257.53484      23468.995      23468.995     -463.45243     -463.45243    
Loop time of 230.361 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 63.989 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.81     | 229.81     | 229.81     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10089    | 0.10089    | 0.10089    |   0.0 |  0.04
Output  | 0.00016427 | 0.00016427 | 0.00016427 |   0.0 |  0.00
Modify  | 0.39203    | 0.39203    | 0.39203    |   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:           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:       245238 ave      245238 max      245238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245238
Ave neighs/atom = 122.619
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.799658172276, Press = -1.32082010899013
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8430.2603     -8430.2603     -8496.805      -8496.805       257.53484      257.53484      23468.995      23468.995     -463.45243     -463.45243    
     55000  -8430.8201     -8430.8201     -8496.5953     -8496.5953      254.55658      254.55658      23468.822      23468.822     -514.66255     -514.66255    
Loop time of 232.696 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 232.14     | 232.14     | 232.14     |   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.00016446 | 0.00016446 | 0.00016446 |   0.0 |  0.00
Modify  | 0.39232    | 0.39232    | 0.39232    |   0.0 |  0.17
Other   |            | 0.06151    |            |       |  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:       245360 ave      245360 max      245360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245360
Ave neighs/atom = 122.68
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.813158095822, Press = -1.86221162403212
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8430.8201     -8430.8201     -8496.5953     -8496.5953      254.55658      254.55658      23468.822      23468.822     -514.66255     -514.66255    
     56000  -8430.9681     -8430.9681     -8496.2656     -8496.2656      252.708        252.708        23477.572      23477.572     -1174.0558     -1174.0558    
Loop time of 231.985 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.372 ns/day, 64.440 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.10239    | 0.10239    | 0.10239    |   0.0 |  0.04
Output  | 0.00019764 | 0.00019764 | 0.00019764 |   0.0 |  0.00
Modify  | 0.39532    | 0.39532    | 0.39532    |   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:           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:       245340 ave      245340 max      245340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245340
Ave neighs/atom = 122.67
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.820408663856, Press = 0.170362149250843
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8430.9681     -8430.9681     -8496.2656     -8496.2656      252.708        252.708        23477.572      23477.572     -1174.0558     -1174.0558    
     57000  -8431.1688     -8431.1688     -8496.7488     -8496.7488      253.80139      253.80139      23404.367      23404.367      4521.9426      4521.9426    
Loop time of 232.652 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.371 ns/day, 64.626 hours/ns, 4.298 timesteps/s
99.9% 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.1      | 232.1      | 232.1      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10107    | 0.10107    | 0.10107    |   0.0 |  0.04
Output  | 0.00024829 | 0.00024829 | 0.00024829 |   0.0 |  0.00
Modify  | 0.39101    | 0.39101    | 0.39101    |   0.0 |  0.17
Other   |            | 0.06114    |            |       |  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:       245288 ave      245288 max      245288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245288
Ave neighs/atom = 122.644
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.830122681939, Press = -0.899389326488385
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8431.1688     -8431.1688     -8496.7488     -8496.7488      253.80139      253.80139      23404.367      23404.367      4521.9426      4521.9426    
     58000  -8430.3751     -8430.3751     -8494.8308     -8494.8308      249.45032      249.45032      23484.196      23484.196     -1164.8693     -1164.8693    
Loop time of 231.533 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.98     | 230.98     | 230.98     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10257    | 0.10257    | 0.10257    |   0.0 |  0.04
Output  | 0.00016584 | 0.00016584 | 0.00016584 |   0.0 |  0.00
Modify  | 0.39167    | 0.39167    | 0.39167    |   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:           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:       246480 ave      246480 max      246480 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 246480
Ave neighs/atom = 123.24
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.844714093733, Press = -1.24778047616045
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8430.3751     -8430.3751     -8494.8308     -8494.8308      249.45032      249.45032      23484.196      23484.196     -1164.8693     -1164.8693    
     59000  -8431.8488     -8431.8488     -8496.4829     -8496.4829      250.14063      250.14063      23457.015      23457.015      398.14307      398.14307    
Loop time of 229.173 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.377 ns/day, 63.659 hours/ns, 4.364 timesteps/s
99.9% 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.62     | 228.62     | 228.62     |   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.00016461 | 0.00016461 | 0.00016461 |   0.0 |  0.00
Modify  | 0.38884    | 0.38884    | 0.38884    |   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:           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:       245130 ave      245130 max      245130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245130
Ave neighs/atom = 122.565
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.846752108107, Press = -0.701120544827636
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8431.8488     -8431.8488     -8496.4829     -8496.4829      250.14063      250.14063      23457.015      23457.015      398.14307      398.14307    
     60000  -8434.2498     -8434.2498     -8499.2093     -8499.2093      251.39998      251.39998      23454.107      23454.107     -48.232493     -48.232493    
Loop time of 232.995 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.371 ns/day, 64.721 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.43     | 232.43     | 232.43     |   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.0001631  | 0.0001631  | 0.0001631  |   0.0 |  0.00
Modify  | 0.399      | 0.399      | 0.399      |   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:           4125 ave        4125 max        4125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245432 ave      245432 max      245432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245432
Ave neighs/atom = 122.716
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.840415997228, Press = -0.795765770912511
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8434.2498     -8434.2498     -8499.2093     -8499.2093      251.39998      251.39998      23454.107      23454.107     -48.232493     -48.232493    
     61000  -8430.7549     -8430.7549     -8496.6848     -8496.6848      255.15554      255.15554      23475.988      23475.988     -910.54183     -910.54183    
Loop time of 226.478 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 225.94     | 225.94     | 225.94     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099597   | 0.099597   | 0.099597   |   0.0 |  0.04
Output  | 0.00016472 | 0.00016472 | 0.00016472 |   0.0 |  0.00
Modify  | 0.38023    | 0.38023    | 0.38023    |   0.0 |  0.17
Other   |            | 0.06047    |            |       |  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:       245516 ave      245516 max      245516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.380 ns/day, 63.149 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.79     | 226.79     | 226.79     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099341   | 0.099341   | 0.099341   |   0.0 |  0.04
Output  | 0.00016095 | 0.00016095 | 0.00016095 |   0.0 |  0.00
Modify  | 0.38104    | 0.38104    | 0.38104    |   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:           4127 ave        4127 max        4127 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245108 ave      245108 max      245108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245108
Ave neighs/atom = 122.554
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.777883597066, Press = -0.31232587870911
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8433.199      -8433.199      -8497.7956     -8497.7956      249.99541      249.99541      23455.828      23455.828      181.29039      181.29039    
     63000  -8433.2634     -8433.2634     -8498.8339     -8498.8339      253.76459      253.76459      23431.606      23431.606      1765.1175      1765.1175    
Loop time of 227.873 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.10028    | 0.10028    | 0.10028    |   0.0 |  0.04
Output  | 0.00016395 | 0.00016395 | 0.00016395 |   0.0 |  0.00
Modify  | 0.38393    | 0.38393    | 0.38393    |   0.0 |  0.17
Other   |            | 0.06065    |            |       |  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:       245588 ave      245588 max      245588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245588
Ave neighs/atom = 122.794
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.781986746655, Press = -1.09017087817312
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8433.2634     -8433.2634     -8498.8339     -8498.8339      253.76459      253.76459      23431.606      23431.606      1765.1175      1765.1175    
     64000  -8429.1882     -8429.1882     -8495.0521     -8495.0521      254.90014      254.90014      23486.265      23486.265     -1304.8938     -1304.8938    
Loop time of 231.026 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.174 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.48     | 230.48     | 230.48     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10063    | 0.10063    | 0.10063    |   0.0 |  0.04
Output  | 0.00016641 | 0.00016641 | 0.00016641 |   0.0 |  0.00
Modify  | 0.38781    | 0.38781    | 0.38781    |   0.0 |  0.17
Other   |            | 0.06053    |            |       |  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:       245866 ave      245866 max      245866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245866
Ave neighs/atom = 122.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 = 252.772751155961, Press = -1.52430359177878
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 4.134 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -8429.1882     -8429.1882     -8495.0521     -8495.0521      254.90014      254.90014      23486.265      23486.265     -1304.8938     -1304.8938    
     65000  -8432.5855     -8432.5855     -8498.957      -8498.957       256.86471      256.86471      23479.191      23479.191     -1766.4957     -1766.4957    
Loop time of 231.731 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.370 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.16     | 231.16     | 231.16     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10314    | 0.10314    | 0.10314    |   0.0 |  0.04
Output  | 0.00016335 | 0.00016335 | 0.00016335 |   0.0 |  0.00
Modify  | 0.40035    | 0.40035    | 0.40035    |   0.0 |  0.17
Other   |            | 0.06219    |            |       |  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:       244956 ave      244956 max      244956 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244956
Ave neighs/atom = 122.478
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.811487034591, Press = -0.320929469308525
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8432.5855     -8432.5855     -8498.957      -8498.957       256.86471      256.86471      23479.191      23479.191     -1766.4957     -1766.4957    
     66000  -8428.5607     -8428.5607     -8494.6223     -8494.6223      255.66509      255.66509      23420.526      23420.526      3745.2973      3745.2973    
Loop time of 231.514 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.309 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.96     | 230.96     | 230.96     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10073    | 0.10073    | 0.10073    |   0.0 |  0.04
Output  | 0.0002244  | 0.0002244  | 0.0002244  |   0.0 |  0.00
Modify  | 0.38782    | 0.38782    | 0.38782    |   0.0 |  0.17
Other   |            | 0.06171    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4127 ave        4127 max        4127 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       245068 ave      245068 max      245068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245068
Ave neighs/atom = 122.534
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.832388567321, Press = -0.68804242325407
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8428.5607     -8428.5607     -8494.6223     -8494.6223      255.66509      255.66509      23420.526      23420.526      3745.2973      3745.2973    
     67000  -8432.6745     -8432.6745     -8495.7404     -8495.7404      244.07148      244.07148      23480.014      23480.014     -1192.1391     -1192.1391    
Loop time of 231.345 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.373 ns/day, 64.263 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.8      | 230.8      | 230.8      |   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.00016679 | 0.00016679 | 0.00016679 |   0.0 |  0.00
Modify  | 0.38725    | 0.38725    | 0.38725    |   0.0 |  0.17
Other   |            | 0.06138    |            |       |  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:       246192 ave      246192 max      246192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 246192
Ave neighs/atom = 123.096
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.860946422713, Press = -2.17537671386259
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8432.6745     -8432.6745     -8495.7404     -8495.7404      244.07148      244.07148      23480.014      23480.014     -1192.1391     -1192.1391    
     68000  -8431.1131     -8431.1131     -8497.9845     -8497.9845      258.79906      258.79906      23478.717      23478.717     -1505.2874     -1505.2874    
Loop time of 230.395 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.375 ns/day, 63.999 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.84     | 229.84     | 229.84     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10144    | 0.10144    | 0.10144    |   0.0 |  0.04
Output  | 0.00016494 | 0.00016494 | 0.00016494 |   0.0 |  0.00
Modify  | 0.39329    | 0.39329    | 0.39329    |   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:           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:       244872 ave      244872 max      244872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244872
Ave neighs/atom = 122.436
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.901527756821, Press = 0.0944088074778221
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8431.1131     -8431.1131     -8497.9845     -8497.9845      258.79906      258.79906      23478.717      23478.717     -1505.2874     -1505.2874    
     69000  -8430.057      -8430.057      -8495.607      -8495.607       253.68512      253.68512      23451.6        23451.6        1186.191       1186.191     
Loop time of 230.771 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.374 ns/day, 64.103 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.21     | 230.21     | 230.21     |   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.00016295 | 0.00016295 | 0.00016295 |   0.0 |  0.00
Modify  | 0.39461    | 0.39461    | 0.39461    |   0.0 |  0.17
Other   |            | 0.06216    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4123 ave        4123 max        4123 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       244906 ave      244906 max      244906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 244906
Ave neighs/atom = 122.453
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.933835967667, Press = -0.74312176193123
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8430.057      -8430.057      -8495.607      -8495.607       253.68512      253.68512      23451.6        23451.6        1186.191       1186.191     
     70000  -8431.6085     -8431.6085     -8497.1894     -8497.1894      253.80479      253.80479      23472.14       23472.14      -740.03661     -740.03661    
Loop time of 232.642 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.371 ns/day, 64.623 hours/ns, 4.298 timesteps/s
99.9% 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.09     | 232.09     | 232.09     |   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.0001644  | 0.0001644  | 0.0001644  |   0.0 |  0.00
Modify  | 0.39294    | 0.39294    | 0.39294    |   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:           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:       245474 ave      245474 max      245474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245474
Ave neighs/atom = 122.737
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.95800271084, Press = -0.659994621216693
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8431.6085     -8431.6085     -8497.1894     -8497.1894      253.80479      253.80479      23472.14       23472.14      -740.03661     -740.03661    
     71000  -8432.2299     -8432.2299     -8497.8801     -8497.8801      254.073        254.073        23448.227      23448.227      710.37622      710.37622    
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.98     | 230.98     | 230.98     |   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.00016562 | 0.00016562 | 0.00016562 |   0.0 |  0.00
Modify  | 0.38795    | 0.38795    | 0.38795    |   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:           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:       245172 ave      245172 max      245172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245172
Ave neighs/atom = 122.586
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.987415511269, Press = -0.98062360864373
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8432.2299     -8432.2299     -8497.8801     -8497.8801      254.073        254.073        23448.227      23448.227      710.37622      710.37622    
     72000  -8434.3149     -8434.3149     -8497.9683     -8497.9683      246.34513      246.34513      23489.726      23489.726     -2563.8413     -2563.8413    
Loop time of 234.678 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.368 ns/day, 65.188 hours/ns, 4.261 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 234.11     | 234.11     | 234.11     |   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.00016503 | 0.00016503 | 0.00016503 |   0.0 |  0.00
Modify  | 0.40003    | 0.40003    | 0.40003    |   0.0 |  0.17
Other   |            | 0.06215    |            |       |  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:       245708 ave      245708 max      245708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245708
Ave neighs/atom = 122.854
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.97280054563, Press = -0.909007262603782
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.134 | 4.134 | 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  -8434.3149     -8434.3149     -8497.9683     -8497.9683      246.34513      246.34513      23489.726      23489.726     -2563.8413     -2563.8413    
     73000  -8431.6011     -8431.6011     -8497.8323     -8497.8323      256.3217       256.3217       23434.613      23434.613      1825.615       1825.615     
Loop time of 233.858 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.369 ns/day, 64.961 hours/ns, 4.276 timesteps/s
99.9% 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.29     | 233.29     | 233.29     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10343    | 0.10343    | 0.10343    |   0.0 |  0.04
Output  | 0.00016664 | 0.00016664 | 0.00016664 |   0.0 |  0.00
Modify  | 0.3993     | 0.3993     | 0.3993     |   0.0 |  0.17
Other   |            | 0.0619     |            |       |  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:       245042 ave      245042 max      245042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 245042
Ave neighs/atom = 122.521
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
23463.0637010627

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0