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

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

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

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

kim_interactions Cu

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

kim interactions Cu
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_WangOhLee_2020_CuCo__MO_694335101831_002
pair_coeff * * Cu
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 63.546

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 47175.6294254851 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_694335101831_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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -14029.144     -14029.144     -14160         -14160          253.15         253.15         47175.629      47175.629      2962.745       2962.745     
      1000  -13891.154     -13891.154     -14025.485     -14025.485      259.87077      259.87077      47819.315      47819.315      442.31517      442.31517    
Loop time of 356.686 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.242 ns/day, 99.079 hours/ns, 2.804 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 355.76     | 355.76     | 355.76     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15103    | 0.15103    | 0.15103    |   0.0 |  0.04
Output  | 0.00027996 | 0.00027996 | 0.00027996 |   0.0 |  0.00
Modify  | 0.67633    | 0.67633    | 0.67633    |   0.0 |  0.19
Other   |            | 0.09515    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       536000 ave      536000 max      536000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 536000
Ave neighs/atom = 134
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13891.154     -13891.154     -14025.485     -14025.485      259.87077      259.87077      47819.315      47819.315      442.31517      442.31517    
      2000  -13900.169     -13900.169     -14032.673     -14032.673      256.33861      256.33861      47811.972      47811.972     -61.728879     -61.728879    
Loop time of 335.241 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.258 ns/day, 93.122 hours/ns, 2.983 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 334.29     | 334.29     | 334.29     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1527     | 0.1527     | 0.1527     |   0.0 |  0.05
Output  | 0.00022756 | 0.00022756 | 0.00022756 |   0.0 |  0.00
Modify  | 0.69553    | 0.69553    | 0.69553    |   0.0 |  0.21
Other   |            | 0.09803    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446156 ave      446156 max      446156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446156
Ave neighs/atom = 111.539
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13900.169     -13900.169     -14032.673     -14032.673      256.33861      256.33861      47811.972      47811.972     -61.728879     -61.728879    
      3000  -13897.662     -13897.662     -14031.622     -14031.622      259.15446      259.15446      47835.404      47835.404     -463.39894     -463.39894    
Loop time of 339.841 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.400 hours/ns, 2.943 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.88     | 338.88     | 338.88     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15393    | 0.15393    | 0.15393    |   0.0 |  0.05
Output  | 0.00029141 | 0.00029141 | 0.00029141 |   0.0 |  0.00
Modify  | 0.71112    | 0.71112    | 0.71112    |   0.0 |  0.21
Other   |            | 0.09784    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446224 ave      446224 max      446224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446224
Ave neighs/atom = 111.556
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13897.662     -13897.662     -14031.622     -14031.622      259.15446      259.15446      47835.404      47835.404     -463.39894     -463.39894    
      4000  -13897.892     -13897.892     -14028.238     -14028.238      252.16278      252.16278      47854.41       47854.41      -787.92383     -787.92383    
Loop time of 338.212 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 93.948 hours/ns, 2.957 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.25     | 337.25     | 337.25     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15149    | 0.15149    | 0.15149    |   0.0 |  0.04
Output  | 0.00023087 | 0.00023087 | 0.00023087 |   0.0 |  0.00
Modify  | 0.70791    | 0.70791    | 0.70791    |   0.0 |  0.21
Other   |            | 0.09784    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445756 ave      445756 max      445756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445756
Ave neighs/atom = 111.439
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13897.892     -13897.892     -14028.238     -14028.238      252.16278      252.16278      47854.41       47854.41      -787.92383     -787.92383    
      5000  -13900.495     -13900.495     -14027.377     -14027.377      245.46265      245.46265      47857.258      47857.258     -765.09351     -765.09351    
Loop time of 336.739 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.539 hours/ns, 2.970 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 335.79     | 335.79     | 335.79     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15175    | 0.15175    | 0.15175    |   0.0 |  0.05
Output  | 0.00023668 | 0.00023668 | 0.00023668 |   0.0 |  0.00
Modify  | 0.704      | 0.704      | 0.704      |   0.0 |  0.21
Other   |            | 0.09759    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444858 ave      444858 max      444858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444858
Ave neighs/atom = 111.2145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 254.404964991979, Press = -50.0286123726871
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13900.495     -13900.495     -14027.377     -14027.377      245.46265      245.46265      47857.258      47857.258     -765.09351     -765.09351    
      6000  -13895.302     -13895.302     -14030.37      -14030.37       261.29721      261.29721      47874.139      47874.139     -1380.0524     -1380.0524    
Loop time of 338.95 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.153 hours/ns, 2.950 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.96     | 337.96     | 337.96     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15314    | 0.15314    | 0.15314    |   0.0 |  0.05
Output  | 0.00019166 | 0.00019166 | 0.00019166 |   0.0 |  0.00
Modify  | 0.73755    | 0.73755    | 0.73755    |   0.0 |  0.22
Other   |            | 0.09922    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444800 ave      444800 max      444800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444800
Ave neighs/atom = 111.2
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.675427049641, Press = 10.9561169950379
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13895.302     -13895.302     -14030.37      -14030.37       261.29721      261.29721      47874.139      47874.139     -1380.0524     -1380.0524    
      7000  -13900.818     -13900.818     -14030.162     -14030.162      250.22521      250.22521      47860.016      47860.016     -1100.7324     -1100.7324    
Loop time of 334.406 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.258 ns/day, 92.891 hours/ns, 2.990 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 333.43     | 333.43     | 333.43     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15237    | 0.15237    | 0.15237    |   0.0 |  0.05
Output  | 0.00018925 | 0.00018925 | 0.00018925 |   0.0 |  0.00
Modify  | 0.72286    | 0.72286    | 0.72286    |   0.0 |  0.22
Other   |            | 0.09735    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444306 ave      444306 max      444306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444306
Ave neighs/atom = 111.0765
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.062926405986, Press = 8.16224158507356
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13900.818     -13900.818     -14030.162     -14030.162      250.22521      250.22521      47860.016      47860.016     -1100.7324     -1100.7324    
      8000  -13899.619     -13899.619     -14028.371     -14028.371      249.08023      249.08023      47857.003      47857.003     -844.14038     -844.14038    
Loop time of 336.393 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.443 hours/ns, 2.973 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 335.42     | 335.42     | 335.42     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15228    | 0.15228    | 0.15228    |   0.0 |  0.05
Output  | 0.00019004 | 0.00019004 | 0.00019004 |   0.0 |  0.00
Modify  | 0.7275     | 0.7275     | 0.7275     |   0.0 |  0.22
Other   |            | 0.09742    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444836 ave      444836 max      444836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444836
Ave neighs/atom = 111.209
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.076892061478, Press = 9.71576761819237
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13899.619     -13899.619     -14028.371     -14028.371      249.08023      249.08023      47857.003      47857.003     -844.14038     -844.14038    
      9000  -13894.193     -13894.193     -14025.313     -14025.313      253.66064      253.66064      47851.931      47851.931     -210.61596     -210.61596    
Loop time of 342.346 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.096 hours/ns, 2.921 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 341.34     | 341.34     | 341.34     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15456    | 0.15456    | 0.15456    |   0.0 |  0.05
Output  | 0.00018871 | 0.00018871 | 0.00018871 |   0.0 |  0.00
Modify  | 0.75162    | 0.75162    | 0.75162    |   0.0 |  0.22
Other   |            | 0.09905    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445232 ave      445232 max      445232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445232
Ave neighs/atom = 111.308
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.342494016155, Press = 8.70240574637711
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13894.193     -13894.193     -14025.313     -14025.313      253.66064      253.66064      47851.931      47851.931     -210.61596     -210.61596    
     10000  -13896.962     -13896.962     -14026.68      -14026.68       250.94912      250.94912      47840.66       47840.66      -155.94134     -155.94134    
Loop time of 339.094 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.193 hours/ns, 2.949 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.11     | 338.11     | 338.11     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15287    | 0.15287    | 0.15287    |   0.0 |  0.05
Output  | 0.00024111 | 0.00024111 | 0.00024111 |   0.0 |  0.00
Modify  | 0.73748    | 0.73748    | 0.73748    |   0.0 |  0.22
Other   |            | 0.09832    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445138 ave      445138 max      445138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445138
Ave neighs/atom = 111.2845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.253097286956, Press = 8.98708337137383
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13896.962     -13896.962     -14026.68      -14026.68       250.94912      250.94912      47840.66       47840.66      -155.94134     -155.94134    
     11000  -13900.07      -13900.07      -14029.121     -14029.121      249.65844      249.65844      47811.119      47811.119      347.91715      347.91715    
Loop time of 340.073 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.465 hours/ns, 2.941 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.09     | 339.09     | 339.09     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15325    | 0.15325    | 0.15325    |   0.0 |  0.05
Output  | 0.00024503 | 0.00024503 | 0.00024503 |   0.0 |  0.00
Modify  | 0.73599    | 0.73599    | 0.73599    |   0.0 |  0.22
Other   |            | 0.09791    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445640 ave      445640 max      445640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445640
Ave neighs/atom = 111.41
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.050301670862, Press = 3.79463068282484
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13900.07      -13900.07      -14029.121     -14029.121      249.65844      249.65844      47811.119      47811.119      347.91715      347.91715    
     12000  -13894.356     -13894.356     -14027.856     -14027.856      258.26527      258.26527      47817.166      47817.166      554.51595      554.51595    
Loop time of 339.833 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.398 hours/ns, 2.943 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.84     | 338.84     | 338.84     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15248    | 0.15248    | 0.15248    |   0.0 |  0.04
Output  | 0.00028704 | 0.00028704 | 0.00028704 |   0.0 |  0.00
Modify  | 0.74019    | 0.74019    | 0.74019    |   0.0 |  0.22
Other   |            | 0.09879    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446744 ave      446744 max      446744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446744
Ave neighs/atom = 111.686
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.121101491785, Press = 2.24809549469016
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13894.356     -13894.356     -14027.856     -14027.856      258.26527      258.26527      47817.166      47817.166      554.51595      554.51595    
     13000  -13899.103     -13899.103     -14029.904     -14029.904      253.04408      253.04408      47778.24       47778.24       1272.7562      1272.7562    
Loop time of 341.1 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.750 hours/ns, 2.932 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 340.11     | 340.11     | 340.11     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15249    | 0.15249    | 0.15249    |   0.0 |  0.04
Output  | 0.00019595 | 0.00019595 | 0.00019595 |   0.0 |  0.00
Modify  | 0.73986    | 0.73986    | 0.73986    |   0.0 |  0.22
Other   |            | 0.09862    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446626 ave      446626 max      446626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446626
Ave neighs/atom = 111.6565
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.199236783381, Press = 1.40317834604843
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13899.103     -13899.103     -14029.904     -14029.904      253.04408      253.04408      47778.24       47778.24       1272.7562      1272.7562    
     14000  -13897.677     -13897.677     -14027.659     -14027.659      251.45941      251.45941      47769.824      47769.824      1708.4005      1708.4005    
Loop time of 342.313 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.087 hours/ns, 2.921 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 341.31     | 341.31     | 341.31     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15409    | 0.15409    | 0.15409    |   0.0 |  0.05
Output  | 0.00019326 | 0.00019326 | 0.00019326 |   0.0 |  0.00
Modify  | 0.75106    | 0.75106    | 0.75106    |   0.0 |  0.22
Other   |            | 0.0994     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       448020 ave      448020 max      448020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 448020
Ave neighs/atom = 112.005
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.40731088011, Press = -0.95575329066185
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13897.677     -13897.677     -14027.659     -14027.659      251.45941      251.45941      47769.824      47769.824      1708.4005      1708.4005    
     15000  -13898.712     -13898.712     -14029.58      -14029.58       253.17251      253.17251      47774.279      47774.279      1492.9659      1492.9659    
Loop time of 342.312 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.087 hours/ns, 2.921 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 341.31     | 341.31     | 341.31     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15428    | 0.15428    | 0.15428    |   0.0 |  0.05
Output  | 0.00027478 | 0.00027478 | 0.00027478 |   0.0 |  0.00
Modify  | 0.74473    | 0.74473    | 0.74473    |   0.0 |  0.22
Other   |            | 0.09852    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447818 ave      447818 max      447818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447818
Ave neighs/atom = 111.9545
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.362237335275, Press = -1.73352042892664
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13898.712     -13898.712     -14029.58      -14029.58       253.17251      253.17251      47774.279      47774.279      1492.9659      1492.9659    
     16000  -13897.928     -13897.928     -14029.161     -14029.161      253.87854      253.87854      47801.398      47801.398      713.10637      713.10637    
Loop time of 342.879 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.244 hours/ns, 2.916 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 341.88     | 341.88     | 341.88     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15435    | 0.15435    | 0.15435    |   0.0 |  0.05
Output  | 0.00018924 | 0.00018924 | 0.00018924 |   0.0 |  0.00
Modify  | 0.74646    | 0.74646    | 0.74646    |   0.0 |  0.22
Other   |            | 0.09777    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       448204 ave      448204 max      448204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 448204
Ave neighs/atom = 112.051
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.356522662952, Press = -2.66201546358204
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13897.928     -13897.928     -14029.161     -14029.161      253.87854      253.87854      47801.398      47801.398      713.10637      713.10637    
     17000  -13900.901     -13900.901     -14028.276     -14028.276      246.41611      246.41611      47820.955      47820.955      209.71171      209.71171    
Loop time of 341.772 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.937 hours/ns, 2.926 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 340.77     | 340.77     | 340.77     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15272    | 0.15272    | 0.15272    |   0.0 |  0.04
Output  | 0.00026054 | 0.00026054 | 0.00026054 |   0.0 |  0.00
Modify  | 0.74934    | 0.74934    | 0.74934    |   0.0 |  0.22
Other   |            | 0.09879    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446986 ave      446986 max      446986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446986
Ave neighs/atom = 111.7465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.345140281355, Press = -1.47301107566071
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13900.901     -13900.901     -14028.276     -14028.276      246.41611      246.41611      47820.955      47820.955      209.71171      209.71171    
     18000  -13898.596     -13898.596     -14028.937     -14028.937      252.15322      252.15322      47834.305      47834.305     -220.67182     -220.67182    
Loop time of 339.701 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.361 hours/ns, 2.944 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.7      | 338.7      | 338.7      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15338    | 0.15338    | 0.15338    |   0.0 |  0.05
Output  | 0.00019013 | 0.00019013 | 0.00019013 |   0.0 |  0.00
Modify  | 0.7453     | 0.7453     | 0.7453     |   0.0 |  0.22
Other   |            | 0.09846    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446086 ave      446086 max      446086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446086
Ave neighs/atom = 111.5215
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.36232354138, Press = -0.468583565652279
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13898.596     -13898.596     -14028.937     -14028.937      252.15322      252.15322      47834.305      47834.305     -220.67182     -220.67182    
     19000  -13898.539     -13898.539     -14026.536     -14026.536      247.61772      247.61772      47827.109      47827.109      206.96766      206.96766    
Loop time of 341.941 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.983 hours/ns, 2.924 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 340.94     | 340.94     | 340.94     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15442    | 0.15442    | 0.15442    |   0.0 |  0.05
Output  | 0.00023951 | 0.00023951 | 0.00023951 |   0.0 |  0.00
Modify  | 0.74945    | 0.74945    | 0.74945    |   0.0 |  0.22
Other   |            | 0.09939    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445712 ave      445712 max      445712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445712
Ave neighs/atom = 111.428
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.298294784312, Press = 0.714245445968189
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13898.539     -13898.539     -14026.536     -14026.536      247.61772      247.61772      47827.109      47827.109      206.96766      206.96766    
     20000  -13898.517     -13898.517     -14028.402     -14028.402      251.27134      251.27134      47831.064      47831.064     -73.450805     -73.450805    
Loop time of 337.805 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.835 hours/ns, 2.960 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.82     | 336.82     | 336.82     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15333    | 0.15333    | 0.15333    |   0.0 |  0.05
Output  | 0.00019298 | 0.00019298 | 0.00019298 |   0.0 |  0.00
Modify  | 0.73408    | 0.73408    | 0.73408    |   0.0 |  0.22
Other   |            | 0.09776    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445776 ave      445776 max      445776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445776
Ave neighs/atom = 111.444
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.287863673509, Press = 0.37585441049251
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13898.517     -13898.517     -14028.402     -14028.402      251.27134      251.27134      47831.064      47831.064     -73.450805     -73.450805    
     21000  -13896.015     -13896.015     -14026.901     -14026.901      253.20876      253.20876      47817.542      47817.542      543.37825      543.37825    
Loop time of 336.285 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.412 hours/ns, 2.974 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 335.3      | 335.3      | 335.3      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15205    | 0.15205    | 0.15205    |   0.0 |  0.05
Output  | 0.00019071 | 0.00019071 | 0.00019071 |   0.0 |  0.00
Modify  | 0.73018    | 0.73018    | 0.73018    |   0.0 |  0.22
Other   |            | 0.09841    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445572 ave      445572 max      445572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445572
Ave neighs/atom = 111.393
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.262736373761, Press = 1.25711720619927
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13896.015     -13896.015     -14026.901     -14026.901      253.20876      253.20876      47817.542      47817.542      543.37825      543.37825    
     22000  -13898.601     -13898.601     -14029.818     -14029.818      253.84826      253.84826      47781.945      47781.945      1223.8031      1223.8031    
Loop time of 338.309 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 93.975 hours/ns, 2.956 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.33     | 337.33     | 337.33     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1515     | 0.1515     | 0.1515     |   0.0 |  0.04
Output  | 0.00018641 | 0.00018641 | 0.00018641 |   0.0 |  0.00
Modify  | 0.73177    | 0.73177    | 0.73177    |   0.0 |  0.22
Other   |            | 0.09718    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446502 ave      446502 max      446502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446502
Ave neighs/atom = 111.6255
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.330336727411, Press = 0.877579689727755
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13898.601     -13898.601     -14029.818     -14029.818      253.84826      253.84826      47781.945      47781.945      1223.8031      1223.8031    
     23000  -13899.878     -13899.878     -14030.334     -14030.334      252.37643      252.37643      47771.686      47771.686      1410.1121      1410.1121    
Loop time of 337.25 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.680 hours/ns, 2.965 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.26     | 336.26     | 336.26     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15235    | 0.15235    | 0.15235    |   0.0 |  0.05
Output  | 0.00018842 | 0.00018842 | 0.00018842 |   0.0 |  0.00
Modify  | 0.73606    | 0.73606    | 0.73606    |   0.0 |  0.22
Other   |            | 0.09824    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447828 ave      447828 max      447828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447828
Ave neighs/atom = 111.957
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.358079964634, Press = 0.4535159241911
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13899.878     -13899.878     -14030.334     -14030.334      252.37643      252.37643      47771.686      47771.686      1410.1121      1410.1121    
     24000  -13895.094     -13895.094     -14029.31      -14029.31       259.65071      259.65071      47793.411      47793.411      969.80636      969.80636    
Loop time of 338.102 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.917 hours/ns, 2.958 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.11     | 337.11     | 337.11     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.153      | 0.153      | 0.153      |   0.0 |  0.05
Output  | 0.00028683 | 0.00028683 | 0.00028683 |   0.0 |  0.00
Modify  | 0.73896    | 0.73896    | 0.73896    |   0.0 |  0.22
Other   |            | 0.09919    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       448098 ave      448098 max      448098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 448098
Ave neighs/atom = 112.0245
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.394748976174, Press = -0.646916477367741
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13895.094     -13895.094     -14029.31      -14029.31       259.65071      259.65071      47793.411      47793.411      969.80636      969.80636    
     25000  -13899.302     -13899.302     -14029.587     -14029.587      252.04372      252.04372      47762.665      47762.665      1851.1377      1851.1377    
Loop time of 336.889 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.580 hours/ns, 2.968 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 335.91     | 335.91     | 335.91     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15157    | 0.15157    | 0.15157    |   0.0 |  0.04
Output  | 0.00018951 | 0.00018951 | 0.00018951 |   0.0 |  0.00
Modify  | 0.73332    | 0.73332    | 0.73332    |   0.0 |  0.22
Other   |            | 0.09717    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447036 ave      447036 max      447036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447036
Ave neighs/atom = 111.759
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.393878649011, Press = -2.13850701933409
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13899.302     -13899.302     -14029.587     -14029.587      252.04372      252.04372      47762.665      47762.665      1851.1377      1851.1377    
     26000  -13897.88      -13897.88      -14029.059     -14029.059      253.77618      253.77618      47804.364      47804.364      556.70179      556.70179    
Loop time of 337.393 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.720 hours/ns, 2.964 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.41     | 336.41     | 336.41     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15116    | 0.15116    | 0.15116    |   0.0 |  0.04
Output  | 0.00019614 | 0.00019614 | 0.00019614 |   0.0 |  0.00
Modify  | 0.73435    | 0.73435    | 0.73435    |   0.0 |  0.22
Other   |            | 0.09772    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       448698 ave      448698 max      448698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 448698
Ave neighs/atom = 112.1745
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.455625681009, Press = -3.05222937555028
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13897.88      -13897.88      -14029.059     -14029.059      253.77618      253.77618      47804.364      47804.364      556.70179      556.70179    
     27000  -13896.042     -13896.042     -14029.077     -14029.077      257.36592      257.36592      47838.417      47838.417     -303.88782     -303.88782    
Loop time of 337.581 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.772 hours/ns, 2.962 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.6      | 336.6      | 336.6      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1518     | 0.1518     | 0.1518     |   0.0 |  0.04
Output  | 0.00019252 | 0.00019252 | 0.00019252 |   0.0 |  0.00
Modify  | 0.73251    | 0.73251    | 0.73251    |   0.0 |  0.22
Other   |            | 0.09863    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446736 ave      446736 max      446736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446736
Ave neighs/atom = 111.684
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.461502374527, Press = -0.944456353692054
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13896.042     -13896.042     -14029.077     -14029.077      257.36592      257.36592      47838.417      47838.417     -303.88782     -303.88782    
     28000  -13898.606     -13898.606     -14028.316     -14028.316      250.93366      250.93366      47840.427      47840.427     -322.27211     -322.27211    
Loop time of 338.416 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.004 hours/ns, 2.955 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.43     | 337.43     | 337.43     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15324    | 0.15324    | 0.15324    |   0.0 |  0.05
Output  | 0.00019229 | 0.00019229 | 0.00019229 |   0.0 |  0.00
Modify  | 0.73727    | 0.73727    | 0.73727    |   0.0 |  0.22
Other   |            | 0.09904    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445260 ave      445260 max      445260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445260
Ave neighs/atom = 111.315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.532907160913, Press = -0.566579975435488
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13898.606     -13898.606     -14028.316     -14028.316      250.93366      250.93366      47840.427      47840.427     -322.27211     -322.27211    
     29000  -13894.961     -13894.961     -14026.017     -14026.017      253.5379       253.5379       47875.203      47875.203     -1145.6291     -1145.6291    
Loop time of 337.317 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.699 hours/ns, 2.965 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.33     | 336.33     | 336.33     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15218    | 0.15218    | 0.15218    |   0.0 |  0.05
Output  | 0.00019194 | 0.00019194 | 0.00019194 |   0.0 |  0.00
Modify  | 0.73313    | 0.73313    | 0.73313    |   0.0 |  0.22
Other   |            | 0.09801    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445270 ave      445270 max      445270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445270
Ave neighs/atom = 111.3175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.546099426921, Press = 0.57348771635688
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13894.961     -13894.961     -14026.017     -14026.017      253.5379       253.5379       47875.203      47875.203     -1145.6291     -1145.6291    
     30000  -13901.001     -13901.001     -14030.618     -14030.618      250.75304      250.75304      47884.248      47884.248     -1884.9268     -1884.9268    
Loop time of 340.19 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.497 hours/ns, 2.940 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.19     | 339.19     | 339.19     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15324    | 0.15324    | 0.15324    |   0.0 |  0.05
Output  | 0.00029383 | 0.00029383 | 0.00029383 |   0.0 |  0.00
Modify  | 0.74519    | 0.74519    | 0.74519    |   0.0 |  0.22
Other   |            | 0.09841    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444164 ave      444164 max      444164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444164
Ave neighs/atom = 111.041
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.5745967124, Press = 1.91616778974153
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13901.001     -13901.001     -14030.618     -14030.618      250.75304      250.75304      47884.248      47884.248     -1884.9268     -1884.9268    
     31000  -13895.049     -13895.049     -14026.413     -14026.413      254.13266      254.13266      47833.331      47833.331      10.280031      10.280031    
Loop time of 336.62 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.505 hours/ns, 2.971 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 335.64     | 335.64     | 335.64     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15168    | 0.15168    | 0.15168    |   0.0 |  0.05
Output  | 0.00024013 | 0.00024013 | 0.00024013 |   0.0 |  0.00
Modify  | 0.72881    | 0.72881    | 0.72881    |   0.0 |  0.22
Other   |            | 0.09763    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444064 ave      444064 max      444064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444064
Ave neighs/atom = 111.016
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.595152350293, Press = 1.13657719779096
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13895.049     -13895.049     -14026.413     -14026.413      254.13266      254.13266      47833.331      47833.331      10.280031      10.280031    
     32000  -13898.83      -13898.83      -14032.286     -14032.286      258.17916      258.17916      47831.194      47831.194     -446.48021     -446.48021    
Loop time of 335.594 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.221 hours/ns, 2.980 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 334.62     | 334.62     | 334.62     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1505     | 0.1505     | 0.1505     |   0.0 |  0.04
Output  | 0.00019733 | 0.00019733 | 0.00019733 |   0.0 |  0.00
Modify  | 0.72507    | 0.72507    | 0.72507    |   0.0 |  0.22
Other   |            | 0.09795    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445398 ave      445398 max      445398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445398
Ave neighs/atom = 111.3495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.597202589703, Press = 0.537517793794912
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13898.83      -13898.83      -14032.286     -14032.286      258.17916      258.17916      47831.194      47831.194     -446.48021     -446.48021    
     33000  -13895.042     -13895.042     -14027.504     -14027.504      256.25703      256.25703      47825.78       47825.78       306.07032      306.07032    
Loop time of 337.565 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.768 hours/ns, 2.962 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.58     | 336.58     | 336.58     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15201    | 0.15201    | 0.15201    |   0.0 |  0.05
Output  | 0.00018994 | 0.00018994 | 0.00018994 |   0.0 |  0.00
Modify  | 0.73395    | 0.73395    | 0.73395    |   0.0 |  0.22
Other   |            | 0.09768    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445786 ave      445786 max      445786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445786
Ave neighs/atom = 111.4465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.641950610235, Press = 1.296736652402
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13895.042     -13895.042     -14027.504     -14027.504      256.25703      256.25703      47825.78       47825.78       306.07032      306.07032    
     34000  -13899.128     -13899.128     -14029.613     -14029.613      252.43362      252.43362      47795.343      47795.343      840.73148      840.73148    
Loop time of 335.632 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.231 hours/ns, 2.979 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 334.65     | 334.65     | 334.65     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15124    | 0.15124    | 0.15124    |   0.0 |  0.05
Output  | 0.00018953 | 0.00018953 | 0.00018953 |   0.0 |  0.00
Modify  | 0.73125    | 0.73125    | 0.73125    |   0.0 |  0.22
Other   |            | 0.0978     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446102 ave      446102 max      446102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446102
Ave neighs/atom = 111.5255
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.671585229507, Press = 1.65405768356032
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13899.128     -13899.128     -14029.613     -14029.613      252.43362      252.43362      47795.343      47795.343      840.73148      840.73148    
     35000  -13895.514     -13895.514     -14025.655     -14025.655      251.76721      251.76721      47773.277      47773.277      1874.8087      1874.8087    
Loop time of 337.396 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.721 hours/ns, 2.964 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.41     | 336.41     | 336.41     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15123    | 0.15123    | 0.15123    |   0.0 |  0.04
Output  | 0.00018982 | 0.00018982 | 0.00018982 |   0.0 |  0.00
Modify  | 0.73316    | 0.73316    | 0.73316    |   0.0 |  0.22
Other   |            | 0.09742    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447334 ave      447334 max      447334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447334
Ave neighs/atom = 111.8335
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.682191496117, Press = 1.66950103346915
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13895.514     -13895.514     -14025.655     -14025.655      251.76721      251.76721      47773.277      47773.277      1874.8087      1874.8087    
     36000  -13897.159     -13897.159     -14028.15      -14028.15       253.41186      253.41186      47794.524      47794.524      1055.0124      1055.0124    
Loop time of 337.02 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.617 hours/ns, 2.967 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.03     | 336.03     | 336.03     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15247    | 0.15247    | 0.15247    |   0.0 |  0.05
Output  | 0.00019002 | 0.00019002 | 0.00019002 |   0.0 |  0.00
Modify  | 0.7356     | 0.7356     | 0.7356     |   0.0 |  0.22
Other   |            | 0.09822    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447650 ave      447650 max      447650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447650
Ave neighs/atom = 111.9125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.657481501447, Press = 0.574878692641224
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13897.159     -13897.159     -14028.15      -14028.15       253.41186      253.41186      47794.524      47794.524      1055.0124      1055.0124    
     37000  -13903.097     -13903.097     -14030.227     -14030.227      245.94142      245.94142      47783.76       47783.76       1024.3872      1024.3872    
Loop time of 337.402 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.723 hours/ns, 2.964 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.42     | 336.42     | 336.42     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15125    | 0.15125    | 0.15125    |   0.0 |  0.04
Output  | 0.00019116 | 0.00019116 | 0.00019116 |   0.0 |  0.00
Modify  | 0.73273    | 0.73273    | 0.73273    |   0.0 |  0.22
Other   |            | 0.09737    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447648 ave      447648 max      447648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447648
Ave neighs/atom = 111.912
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.6372370903, Press = 0.454493425068362
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13903.097     -13903.097     -14030.227     -14030.227      245.94142      245.94142      47783.76       47783.76       1024.3872      1024.3872    
     38000  -13896.384     -13896.384     -14029.226     -14029.226      256.99266      256.99266      47803.723      47803.723      742.89032      742.89032    
Loop time of 339.1 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.194 hours/ns, 2.949 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.11     | 338.11     | 338.11     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15196    | 0.15196    | 0.15196    |   0.0 |  0.04
Output  | 0.00018996 | 0.00018996 | 0.00018996 |   0.0 |  0.00
Modify  | 0.73629    | 0.73629    | 0.73629    |   0.0 |  0.22
Other   |            | 0.09879    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447558 ave      447558 max      447558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447558
Ave neighs/atom = 111.8895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.599453410917, Press = 0.455770835303358
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13896.384     -13896.384     -14029.226     -14029.226      256.99266      256.99266      47803.723      47803.723      742.89032      742.89032    
     39000  -13899.122     -13899.122     -14028.879     -14028.879      251.02404      251.02404      47767.184      47767.184      1800.972       1800.972     
Loop time of 339.742 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.373 hours/ns, 2.943 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.75     | 338.75     | 338.75     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1532     | 0.1532     | 0.1532     |   0.0 |  0.05
Output  | 0.00018972 | 0.00018972 | 0.00018972 |   0.0 |  0.00
Modify  | 0.74028    | 0.74028    | 0.74028    |   0.0 |  0.22
Other   |            | 0.09893    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447262 ave      447262 max      447262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447262
Ave neighs/atom = 111.8155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.629732259369, Press = 0.694149277323719
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13899.122     -13899.122     -14028.879     -14028.879      251.02404      251.02404      47767.184      47767.184      1800.972       1800.972     
     40000  -13897.453     -13897.453     -14028.388     -14028.388      253.30361      253.30361      47720.379      47720.379      3168.6202      3168.6202    
Loop time of 339.131 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.203 hours/ns, 2.949 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.15     | 338.15     | 338.15     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15263    | 0.15263    | 0.15263    |   0.0 |  0.05
Output  | 0.00023381 | 0.00023381 | 0.00023381 |   0.0 |  0.00
Modify  | 0.73245    | 0.73245    | 0.73245    |   0.0 |  0.22
Other   |            | 0.09857    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       448036 ave      448036 max      448036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 448036
Ave neighs/atom = 112.009
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.602402199593, Press = -0.134851455803116
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13897.453     -13897.453     -14028.388     -14028.388      253.30361      253.30361      47720.379      47720.379      3168.6202      3168.6202    
     41000  -13900.411     -13900.411     -14029.878     -14029.878      250.46119      250.46119      47770.657      47770.657      1469.6233      1469.6233    
Loop time of 337.488 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.747 hours/ns, 2.963 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.51     | 336.51     | 336.51     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15139    | 0.15139    | 0.15139    |   0.0 |  0.04
Output  | 0.00023548 | 0.00023548 | 0.00023548 |   0.0 |  0.00
Modify  | 0.72954    | 0.72954    | 0.72954    |   0.0 |  0.22
Other   |            | 0.09809    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       449928 ave      449928 max      449928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 449928
Ave neighs/atom = 112.482
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.565957017311, Press = -0.463333981211366
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13900.411     -13900.411     -14029.878     -14029.878      250.46119      250.46119      47770.657      47770.657      1469.6233      1469.6233    
     42000  -13893.229     -13893.229     -14027.56      -14027.56       259.87265      259.87265      47826.742      47826.742      234.53696      234.53696    
Loop time of 344.004 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.251 ns/day, 95.557 hours/ns, 2.907 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 343        | 343        | 343        |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15444    | 0.15444    | 0.15444    |   0.0 |  0.04
Output  | 0.00031532 | 0.00031532 | 0.00031532 |   0.0 |  0.00
Modify  | 0.75062    | 0.75062    | 0.75062    |   0.0 |  0.22
Other   |            | 0.09904    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       448096 ave      448096 max      448096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 448096
Ave neighs/atom = 112.024
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.579525655056, Press = -0.220708280655769
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13893.229     -13893.229     -14027.56      -14027.56       259.87265      259.87265      47826.742      47826.742      234.53696      234.53696    
     43000  -13899.624     -13899.624     -14028.335     -14028.335      248.99984      248.99984      47808.892      47808.892      499.51446      499.51446    
Loop time of 341.509 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.864 hours/ns, 2.928 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 340.51     | 340.51     | 340.51     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15325    | 0.15325    | 0.15325    |   0.0 |  0.04
Output  | 0.00030109 | 0.00030109 | 0.00030109 |   0.0 |  0.00
Modify  | 0.74816    | 0.74816    | 0.74816    |   0.0 |  0.22
Other   |            | 0.09841    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445854 ave      445854 max      445854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445854
Ave neighs/atom = 111.4635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.602022386224, Press = -0.578148552270541
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13899.624     -13899.624     -14028.335     -14028.335      248.99984      248.99984      47808.892      47808.892      499.51446      499.51446    
     44000  -13895.246     -13895.246     -14027.673     -14027.673      256.18777      256.18777      47854.786      47854.786     -636.3241      -636.3241     
Loop time of 338.352 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 93.987 hours/ns, 2.956 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.37     | 337.37     | 337.37     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15176    | 0.15176    | 0.15176    |   0.0 |  0.04
Output  | 0.00028764 | 0.00028764 | 0.00028764 |   0.0 |  0.00
Modify  | 0.73548    | 0.73548    | 0.73548    |   0.0 |  0.22
Other   |            | 0.09808    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446674 ave      446674 max      446674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446674
Ave neighs/atom = 111.6685
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.621781902726, Press = -1.29678842655751
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13895.246     -13895.246     -14027.673     -14027.673      256.18777      256.18777      47854.786      47854.786     -636.3241      -636.3241     
     45000  -13895.951     -13895.951     -14026.908     -14026.908      253.34608      253.34608      47865.629      47865.629     -914.00257     -914.00257    
Loop time of 338.359 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 93.989 hours/ns, 2.955 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.37     | 337.37     | 337.37     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15307    | 0.15307    | 0.15307    |   0.0 |  0.05
Output  | 0.00019392 | 0.00019392 | 0.00019392 |   0.0 |  0.00
Modify  | 0.73903    | 0.73903    | 0.73903    |   0.0 |  0.22
Other   |            | 0.09888    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445040 ave      445040 max      445040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445040
Ave neighs/atom = 111.26
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.606041457865, Press = -0.437244474728166
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13895.951     -13895.951     -14026.908     -14026.908      253.34608      253.34608      47865.629      47865.629     -914.00257     -914.00257    
     46000  -13897.281     -13897.281     -14028.447     -14028.447      253.75046      253.75046      47853.778      47853.778     -763.11914     -763.11914    
Loop time of 339.41 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.281 hours/ns, 2.946 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.42     | 338.42     | 338.42     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15291    | 0.15291    | 0.15291    |   0.0 |  0.05
Output  | 0.00030499 | 0.00030499 | 0.00030499 |   0.0 |  0.00
Modify  | 0.7389     | 0.7389     | 0.7389     |   0.0 |  0.22
Other   |            | 0.09812    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444832 ave      444832 max      444832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444832
Ave neighs/atom = 111.208
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.597542653559, Press = -0.161475331975907
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13897.281     -13897.281     -14028.447     -14028.447      253.75046      253.75046      47853.778      47853.778     -763.11914     -763.11914    
     47000  -13897.602     -13897.602     -14026.252     -14026.252      248.88086      248.88086      47868.324      47868.324     -927.05881     -927.05881    
Loop time of 339.502 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.306 hours/ns, 2.945 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.51     | 338.51     | 338.51     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15253    | 0.15253    | 0.15253    |   0.0 |  0.04
Output  | 0.00023794 | 0.00023794 | 0.00023794 |   0.0 |  0.00
Modify  | 0.74279    | 0.74279    | 0.74279    |   0.0 |  0.22
Other   |            | 0.09867    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445078 ave      445078 max      445078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445078
Ave neighs/atom = 111.2695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.627600105513, Press = -0.258067774112708
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -13897.602     -13897.602     -14026.252     -14026.252      248.88086      248.88086      47868.324      47868.324     -927.05881     -927.05881    
     48000  -13899.026     -13899.026     -14026.433     -14026.433      246.47755      246.47755      47861.657      47861.657     -726.10069     -726.10069    
Loop time of 338.081 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.911 hours/ns, 2.958 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.09     | 337.09     | 337.09     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15285    | 0.15285    | 0.15285    |   0.0 |  0.05
Output  | 0.00018951 | 0.00018951 | 0.00018951 |   0.0 |  0.00
Modify  | 0.73816    | 0.73816    | 0.73816    |   0.0 |  0.22
Other   |            | 0.09872    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444620 ave      444620 max      444620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444620
Ave neighs/atom = 111.155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.62325917459, Press = 0.486672377173326
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -13899.026     -13899.026     -14026.433     -14026.433      246.47755      246.47755      47861.657      47861.657     -726.10069     -726.10069    
     49000  -13897.658     -13897.658     -14028.262     -14028.262      252.66238      252.66238      47851.24       47851.24      -654.00329     -654.00329    
Loop time of 342.249 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.069 hours/ns, 2.922 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 341.24     | 341.24     | 341.24     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1549     | 0.1549     | 0.1549     |   0.0 |  0.05
Output  | 0.00019042 | 0.00019042 | 0.00019042 |   0.0 |  0.00
Modify  | 0.75563    | 0.75563    | 0.75563    |   0.0 |  0.22
Other   |            | 0.0997     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444694 ave      444694 max      444694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444694
Ave neighs/atom = 111.1735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.654807549029, Press = 0.643241431342681
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -13897.658     -13897.658     -14028.262     -14028.262      252.66238      252.66238      47851.24       47851.24      -654.00329     -654.00329    
     50000  -13896.054     -13896.054     -14026.052     -14026.052      251.48985      251.48985      47839.406      47839.406     -52.029433     -52.029433    
Loop time of 338.093 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.915 hours/ns, 2.958 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.1      | 337.1      | 337.1      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15299    | 0.15299    | 0.15299    |   0.0 |  0.05
Output  | 0.00023841 | 0.00023841 | 0.00023841 |   0.0 |  0.00
Modify  | 0.73835    | 0.73835    | 0.73835    |   0.0 |  0.22
Other   |            | 0.09875    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444964 ave      444964 max      444964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444964
Ave neighs/atom = 111.241
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.648108126203, Press = 0.638244618071448
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -13896.054     -13896.054     -14026.052     -14026.052      251.48985      251.48985      47839.406      47839.406     -52.029433     -52.029433    
     51000  -13898.746     -13898.746     -14027.73      -14027.73       249.52725      249.52725      47830.297      47830.297     -29.685303     -29.685303    
Loop time of 338.975 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.160 hours/ns, 2.950 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.98     | 337.98     | 337.98     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15303    | 0.15303    | 0.15303    |   0.0 |  0.05
Output  | 0.00023494 | 0.00023494 | 0.00023494 |   0.0 |  0.00
Modify  | 0.74018    | 0.74018    | 0.74018    |   0.0 |  0.22
Other   |            | 0.09836    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445492 ave      445492 max      445492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445492
Ave neighs/atom = 111.373
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.643305110081, Press = 0.591189443711757
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -13898.746     -13898.746     -14027.73      -14027.73       249.52725      249.52725      47830.297      47830.297     -29.685303     -29.685303    
     52000  -13894.846     -13894.846     -14026.734     -14026.734      255.14464      255.14464      47834.912      47834.912      47.426238      47.426238    
Loop time of 338.824 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.118 hours/ns, 2.951 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.83     | 337.83     | 337.83     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15203    | 0.15203    | 0.15203    |   0.0 |  0.04
Output  | 0.0002427  | 0.0002427  | 0.0002427  |   0.0 |  0.00
Modify  | 0.74422    | 0.74422    | 0.74422    |   0.0 |  0.22
Other   |            | 0.09884    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445728 ave      445728 max      445728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445728
Ave neighs/atom = 111.432
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.656792896152, Press = 0.565342938310895
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -13894.846     -13894.846     -14026.734     -14026.734      255.14464      255.14464      47834.912      47834.912      47.426238      47.426238    
     53000  -13899.045     -13899.045     -14029.787     -14029.787      252.93049      252.93049      47836.689      47836.689     -404.75167     -404.75167    
Loop time of 340.61 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.614 hours/ns, 2.936 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.61     | 339.61     | 339.61     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15201    | 0.15201    | 0.15201    |   0.0 |  0.04
Output  | 0.00026023 | 0.00026023 | 0.00026023 |   0.0 |  0.00
Modify  | 0.74505    | 0.74505    | 0.74505    |   0.0 |  0.22
Other   |            | 0.09855    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445492 ave      445492 max      445492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445492
Ave neighs/atom = 111.373
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.64887613551, Press = 1.1467191889699
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -13899.045     -13899.045     -14029.787     -14029.787      252.93049      252.93049      47836.689      47836.689     -404.75167     -404.75167    
     54000  -13895.949     -13895.949     -14026.179     -14026.179      251.93784      251.93784      47802.123      47802.123      991.71043      991.71043    
Loop time of 336.634 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.509 hours/ns, 2.971 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 335.66     | 335.66     | 335.66     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15024    | 0.15024    | 0.15024    |   0.0 |  0.04
Output  | 0.00018851 | 0.00018851 | 0.00018851 |   0.0 |  0.00
Modify  | 0.72946    | 0.72946    | 0.72946    |   0.0 |  0.22
Other   |            | 0.09722    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445786 ave      445786 max      445786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445786
Ave neighs/atom = 111.4465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.664785025617, Press = 1.64573981936272
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -13895.949     -13895.949     -14026.179     -14026.179      251.93784      251.93784      47802.123      47802.123      991.71043      991.71043    
     55000  -13900.815     -13900.815     -14030.358     -14030.358      250.6089       250.6089       47790.225      47790.225      853.40774      853.40774    
Loop time of 336.784 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.551 hours/ns, 2.969 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 335.81     | 335.81     | 335.81     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14962    | 0.14962    | 0.14962    |   0.0 |  0.04
Output  | 0.00018857 | 0.00018857 | 0.00018857 |   0.0 |  0.00
Modify  | 0.72639    | 0.72639    | 0.72639    |   0.0 |  0.22
Other   |            | 0.09718    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446916 ave      446916 max      446916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446916
Ave neighs/atom = 111.729
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.655133548209, Press = 0.732714296803214
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -13900.815     -13900.815     -14030.358     -14030.358      250.6089       250.6089       47790.225      47790.225      853.40774      853.40774    
     56000  -13896.529     -13896.529     -14026.902     -14026.902      252.21549      252.21549      47792.491      47792.491      1169.5608      1169.5608    
Loop time of 339.88 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.411 hours/ns, 2.942 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.89     | 338.89     | 338.89     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15018    | 0.15018    | 0.15018    |   0.0 |  0.04
Output  | 0.00018983 | 0.00018983 | 0.00018983 |   0.0 |  0.00
Modify  | 0.73886    | 0.73886    | 0.73886    |   0.0 |  0.22
Other   |            | 0.09803    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447312 ave      447312 max      447312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447312
Ave neighs/atom = 111.828
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.636932219581, Press = 0.606867714751429
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -13896.529     -13896.529     -14026.902     -14026.902      252.21549      252.21549      47792.491      47792.491      1169.5608      1169.5608    
     57000  -13893.566     -13893.566     -14027.038     -14027.038      258.21004      258.21004      47795.547      47795.547      1206.1514      1206.1514    
Loop time of 341.725 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.924 hours/ns, 2.926 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 340.74     | 340.74     | 340.74     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15127    | 0.15127    | 0.15127    |   0.0 |  0.04
Output  | 0.00029374 | 0.00029374 | 0.00029374 |   0.0 |  0.00
Modify  | 0.7378     | 0.7378     | 0.7378     |   0.0 |  0.22
Other   |            | 0.09712    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447224 ave      447224 max      447224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447224
Ave neighs/atom = 111.806
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.628112278408, Press = 0.281697492561602
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -13893.566     -13893.566     -14027.038     -14027.038      258.21004      258.21004      47795.547      47795.547      1206.1514      1206.1514    
     58000  -13898.499     -13898.499     -14028.756     -14028.756      251.99156      251.99156      47785.148      47785.148      1216.9279      1216.9279    
Loop time of 339.205 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.224 hours/ns, 2.948 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.23     | 338.23     | 338.23     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15002    | 0.15002    | 0.15002    |   0.0 |  0.04
Output  | 0.00026075 | 0.00026075 | 0.00026075 |   0.0 |  0.00
Modify  | 0.73093    | 0.73093    | 0.73093    |   0.0 |  0.22
Other   |            | 0.09696    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447086 ave      447086 max      447086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447086
Ave neighs/atom = 111.7715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.650222337226, Press = -0.0756353536068673
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -13898.499     -13898.499     -14028.756     -14028.756      251.99156      251.99156      47785.148      47785.148      1216.9279      1216.9279    
     59000  -13895.009     -13895.009     -14028.763     -14028.763      258.75713      258.75713      47776.754      47776.754      1480.9614      1480.9614    
Loop time of 340.256 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.516 hours/ns, 2.939 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.27     | 339.27     | 339.27     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15146    | 0.15146    | 0.15146    |   0.0 |  0.04
Output  | 0.00028251 | 0.00028251 | 0.00028251 |   0.0 |  0.00
Modify  | 0.73929    | 0.73929    | 0.73929    |   0.0 |  0.22
Other   |            | 0.09894    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447962 ave      447962 max      447962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447962
Ave neighs/atom = 111.9905
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.64056518953, Press = -0.568578231225307
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -13895.009     -13895.009     -14028.763     -14028.763      258.75713      258.75713      47776.754      47776.754      1480.9614      1480.9614    
     60000  -13897.525     -13897.525     -14027.704     -14027.704      251.84054      251.84054      47796.69       47796.69       931.48737      931.48737    
Loop time of 336.371 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.436 hours/ns, 2.973 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 335.4      | 335.4      | 335.4      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1499     | 0.1499     | 0.1499     |   0.0 |  0.04
Output  | 0.00019122 | 0.00019122 | 0.00019122 |   0.0 |  0.00
Modify  | 0.72819    | 0.72819    | 0.72819    |   0.0 |  0.22
Other   |            | 0.09672    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       448038 ave      448038 max      448038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 448038
Ave neighs/atom = 112.0095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.635955644847, Press = -0.679953531092103
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -13897.525     -13897.525     -14027.704     -14027.704      251.84054      251.84054      47796.69       47796.69       931.48737      931.48737    
     61000  -13894.123     -13894.123     -14028.401     -14028.401      259.77092      259.77092      47834.196      47834.196     -96.253315     -96.253315    
Loop time of 335.495 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.258 ns/day, 93.193 hours/ns, 2.981 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 334.52     | 334.52     | 334.52     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14996    | 0.14996    | 0.14996    |   0.0 |  0.04
Output  | 0.00018969 | 0.00018969 | 0.00018969 |   0.0 |  0.00
Modify  | 0.72537    | 0.72537    | 0.72537    |   0.0 |  0.22
Other   |            | 0.09725    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446872 ave      446872 max      446872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446872
Ave neighs/atom = 111.718
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.626598550032, Press = -0.339878949160774
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -13894.123     -13894.123     -14028.401     -14028.401      259.77092      259.77092      47834.196      47834.196     -96.253315     -96.253315    
     62000  -13900.789     -13900.789     -14029.583     -14029.583      249.16093      249.16093      47828.788      47828.788     -138.66676     -138.66676    
Loop time of 337.426 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.729 hours/ns, 2.964 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.45     | 336.45     | 336.45     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14975    | 0.14975    | 0.14975    |   0.0 |  0.04
Output  | 0.00019215 | 0.00019215 | 0.00019215 |   0.0 |  0.00
Modify  | 0.73084    | 0.73084    | 0.73084    |   0.0 |  0.22
Other   |            | 0.0973     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446044 ave      446044 max      446044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446044
Ave neighs/atom = 111.511
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.621596521892, Press = 0.026507323124032
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -13900.789     -13900.789     -14029.583     -14029.583      249.16093      249.16093      47828.788      47828.788     -138.66676     -138.66676    
     63000  -13898.023     -13898.023     -14029.278     -14029.278      253.92167      253.92167      47829.148      47829.148     -80.924314     -80.924314    
Loop time of 332.034 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.232 hours/ns, 3.012 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 331.07     | 331.07     | 331.07     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14812    | 0.14812    | 0.14812    |   0.0 |  0.04
Output  | 0.00018622 | 0.00018622 | 0.00018622 |   0.0 |  0.00
Modify  | 0.71505    | 0.71505    | 0.71505    |   0.0 |  0.22
Other   |            | 0.09772    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445822 ave      445822 max      445822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445822
Ave neighs/atom = 111.4555
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.624853174742, Press = 0.160636183937742
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -13898.023     -13898.023     -14029.278     -14029.278      253.92167      253.92167      47829.148      47829.148     -80.924314     -80.924314    
     64000  -13897.453     -13897.453     -14029.665     -14029.665      255.77384      255.77384      47818.965      47818.965      179.03038      179.03038    
Loop time of 337.763 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.823 hours/ns, 2.961 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.78     | 336.78     | 336.78     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14978    | 0.14978    | 0.14978    |   0.0 |  0.04
Output  | 0.000235   | 0.000235   | 0.000235   |   0.0 |  0.00
Modify  | 0.73217    | 0.73217    | 0.73217    |   0.0 |  0.22
Other   |            | 0.09708    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445852 ave      445852 max      445852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445852
Ave neighs/atom = 111.463
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.613985282864, Press = 0.355484713184707
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -13897.453     -13897.453     -14029.665     -14029.665      255.77384      255.77384      47818.965      47818.965      179.03038      179.03038    
     65000  -13899.722     -13899.722     -14030.241     -14030.241      252.49928      252.49928      47785.348      47785.348      1066.2473      1066.2473    
Loop time of 334.506 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.258 ns/day, 92.918 hours/ns, 2.989 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 333.53     | 333.53     | 333.53     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15048    | 0.15048    | 0.15048    |   0.0 |  0.04
Output  | 0.00018978 | 0.00018978 | 0.00018978 |   0.0 |  0.00
Modify  | 0.72603    | 0.72603    | 0.72603    |   0.0 |  0.22
Other   |            | 0.09755    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446488 ave      446488 max      446488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446488
Ave neighs/atom = 111.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 = 253.630549429316, Press = 0.123334770708022
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -13899.722     -13899.722     -14030.241     -14030.241      252.49928      252.49928      47785.348      47785.348      1066.2473      1066.2473    
     66000  -13897.038     -13897.038     -14029.845     -14029.845      256.92437      256.92437      47775.842      47775.842      1449.2333      1449.2333    
Loop time of 333.34 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.259 ns/day, 92.594 hours/ns, 3.000 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 332.38     | 332.38     | 332.38     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14943    | 0.14943    | 0.14943    |   0.0 |  0.04
Output  | 0.00018891 | 0.00018891 | 0.00018891 |   0.0 |  0.00
Modify  | 0.71442    | 0.71442    | 0.71442    |   0.0 |  0.21
Other   |            | 0.09612    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447756 ave      447756 max      447756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447756
Ave neighs/atom = 111.939
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.618560283725, Press = -0.423181035029839
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -13897.038     -13897.038     -14029.845     -14029.845      256.92437      256.92437      47775.842      47775.842      1449.2333      1449.2333    
     67000  -13901.561     -13901.561     -14029.522     -14029.522      247.54978      247.54978      47782.288      47782.288      1174.986       1174.986     
Loop time of 334.748 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.258 ns/day, 92.986 hours/ns, 2.987 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 333.78     | 333.78     | 333.78     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14862    | 0.14862    | 0.14862    |   0.0 |  0.04
Output  | 0.00018995 | 0.00018995 | 0.00018995 |   0.0 |  0.00
Modify  | 0.72041    | 0.72041    | 0.72041    |   0.0 |  0.22
Other   |            | 0.09638    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447648 ave      447648 max      447648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447648
Ave neighs/atom = 111.912
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.597666424516, Press = -0.429049135248461
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -13901.561     -13901.561     -14029.522     -14029.522      247.54978      247.54978      47782.288      47782.288      1174.986       1174.986     
     68000  -13896.093     -13896.093     -14028.797     -14028.797      256.72359      256.72359      47821.769      47821.769      190.14652      190.14652    
Loop time of 337.077 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.632 hours/ns, 2.967 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.11     | 336.11     | 336.11     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14908    | 0.14908    | 0.14908    |   0.0 |  0.04
Output  | 0.000187   | 0.000187   | 0.000187   |   0.0 |  0.00
Modify  | 0.72438    | 0.72438    | 0.72438    |   0.0 |  0.21
Other   |            | 0.09698    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447652 ave      447652 max      447652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447652
Ave neighs/atom = 111.913
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.572740959952, Press = -0.373461150361182
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -13896.093     -13896.093     -14028.797     -14028.797      256.72359      256.72359      47821.769      47821.769      190.14652      190.14652    
     69000  -13900.873     -13900.873     -14028.522     -14028.522      246.94518      246.94518      47816.517      47816.517      319.03683      319.03683    
Loop time of 343.786 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.251 ns/day, 95.496 hours/ns, 2.909 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 342.79     | 342.79     | 342.79     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15161    | 0.15161    | 0.15161    |   0.0 |  0.04
Output  | 0.00047896 | 0.00047896 | 0.00047896 |   0.0 |  0.00
Modify  | 0.74922    | 0.74922    | 0.74922    |   0.0 |  0.22
Other   |            | 0.09947    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446254 ave      446254 max      446254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446254
Ave neighs/atom = 111.5635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.566396601989, Press = -0.211846527550679
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -13900.873     -13900.873     -14028.522     -14028.522      246.94518      246.94518      47816.517      47816.517      319.03683      319.03683    
     70000  -13896.274     -13896.274     -14027.838     -14027.838      254.52008      254.52008      47861.398      47861.398     -839.48455     -839.48455    
Loop time of 341.23 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.786 hours/ns, 2.931 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 340.24     | 340.24     | 340.24     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15069    | 0.15069    | 0.15069    |   0.0 |  0.04
Output  | 0.00018952 | 0.00018952 | 0.00018952 |   0.0 |  0.00
Modify  | 0.73822    | 0.73822    | 0.73822    |   0.0 |  0.22
Other   |            | 0.09816    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446524 ave      446524 max      446524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446524
Ave neighs/atom = 111.631
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.534687838946, Press = -0.258567495679016
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -13896.274     -13896.274     -14027.838     -14027.838      254.52008      254.52008      47861.398      47861.398     -839.48455     -839.48455    
     71000  -13897.643     -13897.643     -14026.611     -14026.611      249.49617      249.49617      47877.391      47877.391     -1172.7086     -1172.7086    
Loop time of 341.698 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.916 hours/ns, 2.927 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 340.7      | 340.7      | 340.7      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15088    | 0.15088    | 0.15088    |   0.0 |  0.04
Output  | 0.00022516 | 0.00022516 | 0.00022516 |   0.0 |  0.00
Modify  | 0.74553    | 0.74553    | 0.74553    |   0.0 |  0.22
Other   |            | 0.09809    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444834 ave      444834 max      444834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444834
Ave neighs/atom = 111.2085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.519692224258, Press = -0.103278284919579
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -13897.643     -13897.643     -14026.611     -14026.611      249.49617      249.49617      47877.391      47877.391     -1172.7086     -1172.7086    
     72000  -13899.535     -13899.535     -14028.31      -14028.31       249.12381      249.12381      47856.471      47856.471     -872.52225     -872.52225    
Loop time of 337.72 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.811 hours/ns, 2.961 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.74     | 336.74     | 336.74     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14963    | 0.14963    | 0.14963    |   0.0 |  0.04
Output  | 0.00018922 | 0.00018922 | 0.00018922 |   0.0 |  0.00
Modify  | 0.7294     | 0.7294     | 0.7294     |   0.0 |  0.22
Other   |            | 0.09744    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       443924 ave      443924 max      443924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 443924
Ave neighs/atom = 110.981
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.512854023689, Press = 0.305529246175797
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -13899.535     -13899.535     -14028.31      -14028.31       249.12381      249.12381      47856.471      47856.471     -872.52225     -872.52225    
     73000  -13899.226     -13899.226     -14028.62      -14028.62       250.32129      250.32129      47839.282      47839.282     -364.92777     -364.92777    
Loop time of 337.773 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.826 hours/ns, 2.961 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.79     | 336.79     | 336.79     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15093    | 0.15093    | 0.15093    |   0.0 |  0.04
Output  | 0.00018715 | 0.00018715 | 0.00018715 |   0.0 |  0.00
Modify  | 0.73449    | 0.73449    | 0.73449    |   0.0 |  0.22
Other   |            | 0.09708    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444762 ave      444762 max      444762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444762
Ave neighs/atom = 111.1905
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.50417384295, Press = 0.573336868614749
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -13899.226     -13899.226     -14028.62      -14028.62       250.32129      250.32129      47839.282      47839.282     -364.92777     -364.92777    
     74000  -13896.926     -13896.926     -14029.275     -14029.275      256.03914      256.03914      47823.572      47823.572      32.464034      32.464034    
Loop time of 340.44 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.567 hours/ns, 2.937 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.45     | 339.45     | 339.45     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15041    | 0.15041    | 0.15041    |   0.0 |  0.04
Output  | 0.00018862 | 0.00018862 | 0.00018862 |   0.0 |  0.00
Modify  | 0.73616    | 0.73616    | 0.73616    |   0.0 |  0.22
Other   |            | 0.0987     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445626 ave      445626 max      445626 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445626
Ave neighs/atom = 111.4065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.487709062425, Press = 0.781771911133008
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -13896.926     -13896.926     -14029.275     -14029.275      256.03914      256.03914      47823.572      47823.572      32.464034      32.464034    
     75000  -13902.696     -13902.696     -14030.459     -14030.459      247.16641      247.16641      47759.78       47759.78       1744.9468      1744.9468    
Loop time of 334.724 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.258 ns/day, 92.979 hours/ns, 2.988 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 333.76     | 333.76     | 333.76     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14889    | 0.14889    | 0.14889    |   0.0 |  0.04
Output  | 0.00018735 | 0.00018735 | 0.00018735 |   0.0 |  0.00
Modify  | 0.72216    | 0.72216    | 0.72216    |   0.0 |  0.22
Other   |            | 0.09694    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446242 ave      446242 max      446242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446242
Ave neighs/atom = 111.5605
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.46526277405, Press = 0.816070987742664
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -13902.696     -13902.696     -14030.459     -14030.459      247.16641      247.16641      47759.78       47759.78       1744.9468      1744.9468    
     76000  -13896.67      -13896.67      -14028.383     -14028.383      254.80781      254.80781      47787.006      47787.006      1211.4543      1211.4543    
Loop time of 339.258 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.238 hours/ns, 2.948 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.27     | 338.27     | 338.27     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15017    | 0.15017    | 0.15017    |   0.0 |  0.04
Output  | 0.00026314 | 0.00026314 | 0.00026314 |   0.0 |  0.00
Modify  | 0.73772    | 0.73772    | 0.73772    |   0.0 |  0.22
Other   |            | 0.09744    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       448742 ave      448742 max      448742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 448742
Ave neighs/atom = 112.1855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.441564103379, Press = 0.340814433407302
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -13896.67      -13896.67      -14028.383     -14028.383      254.80781      254.80781      47787.006      47787.006      1211.4543      1211.4543    
     77000  -13900.36      -13900.36      -14031.002     -14031.002      252.73758      252.73758      47805.638      47805.638      462.9246       462.9246     
Loop time of 340.759 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.655 hours/ns, 2.935 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.77     | 339.77     | 339.77     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15096    | 0.15096    | 0.15096    |   0.0 |  0.04
Output  | 0.00018838 | 0.00018838 | 0.00018838 |   0.0 |  0.00
Modify  | 0.74109    | 0.74109    | 0.74109    |   0.0 |  0.22
Other   |            | 0.09876    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447184 ave      447184 max      447184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447184
Ave neighs/atom = 111.796
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.434528412229, Press = -0.0450640365681576
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -13900.36      -13900.36      -14031.002     -14031.002      252.73758      252.73758      47805.638      47805.638      462.9246       462.9246     
     78000  -13898.084     -13898.084     -14030.212     -14030.212      255.61142      255.61142      47836.315      47836.315     -360.3025      -360.3025     
Loop time of 338.521 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.034 hours/ns, 2.954 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.54     | 337.54     | 337.54     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15014    | 0.15014    | 0.15014    |   0.0 |  0.04
Output  | 0.00018853 | 0.00018853 | 0.00018853 |   0.0 |  0.00
Modify  | 0.73729    | 0.73729    | 0.73729    |   0.0 |  0.22
Other   |            | 0.0973     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447036 ave      447036 max      447036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447036
Ave neighs/atom = 111.759
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.449125961143, Press = -0.104026673052207
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -13898.084     -13898.084     -14030.212     -14030.212      255.61142      255.61142      47836.315      47836.315     -360.3025      -360.3025     
     79000  -13896.684     -13896.684     -14027.263     -14027.263      252.61356      252.61356      47881.672      47881.672     -1409.7775     -1409.7775    
Loop time of 337.485 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.746 hours/ns, 2.963 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.5      | 336.5      | 336.5      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15052    | 0.15052    | 0.15052    |   0.0 |  0.04
Output  | 0.00023917 | 0.00023917 | 0.00023917 |   0.0 |  0.00
Modify  | 0.73347    | 0.73347    | 0.73347    |   0.0 |  0.22
Other   |            | 0.09793    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445730 ave      445730 max      445730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445730
Ave neighs/atom = 111.4325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.447682847427, Press = -0.0409217119585992
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -13896.684     -13896.684     -14027.263     -14027.263      252.61356      252.61356      47881.672      47881.672     -1409.7775     -1409.7775    
     80000  -13897.01      -13897.01      -14028.093     -14028.093      253.58848      253.58848      47912.381      47912.381     -2353.6678     -2353.6678    
Loop time of 334.505 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.258 ns/day, 92.918 hours/ns, 2.989 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 333.53     | 333.53     | 333.53     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14912    | 0.14912    | 0.14912    |   0.0 |  0.04
Output  | 0.00019041 | 0.00019041 | 0.00019041 |   0.0 |  0.00
Modify  | 0.7254     | 0.7254     | 0.7254     |   0.0 |  0.22
Other   |            | 0.09717    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444166 ave      444166 max      444166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444166
Ave neighs/atom = 111.0415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.46899320832, Press = 0.316230865570148
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -13897.01      -13897.01      -14028.093     -14028.093      253.58848      253.58848      47912.381      47912.381     -2353.6678     -2353.6678    
     81000  -13896.787     -13896.787     -14030.466     -14030.466      258.60986      258.60986      47860.404      47860.404     -1107.7581     -1107.7581    
Loop time of 337.994 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.887 hours/ns, 2.959 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337        | 337        | 337        |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15208    | 0.15208    | 0.15208    |   0.0 |  0.04
Output  | 0.00033919 | 0.00033919 | 0.00033919 |   0.0 |  0.00
Modify  | 0.74202    | 0.74202    | 0.74202    |   0.0 |  0.22
Other   |            | 0.09826    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       442620 ave      442620 max      442620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 442620
Ave neighs/atom = 110.655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.468155509576, Press = 0.39972180005033
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -13896.787     -13896.787     -14030.466     -14030.466      258.60986      258.60986      47860.404      47860.404     -1107.7581     -1107.7581    
     82000  -13899.272     -13899.272     -14030.028     -14030.028      252.95616      252.95616      47819.11       47819.11       97.944534      97.944534    
Loop time of 339.296 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.249 hours/ns, 2.947 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.3      | 338.3      | 338.3      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15248    | 0.15248    | 0.15248    |   0.0 |  0.04
Output  | 0.00019148 | 0.00019148 | 0.00019148 |   0.0 |  0.00
Modify  | 0.74205    | 0.74205    | 0.74205    |   0.0 |  0.22
Other   |            | 0.09734    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444990 ave      444990 max      444990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444990
Ave neighs/atom = 111.2475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.470051376519, Press = 0.274746861438141
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -13899.272     -13899.272     -14030.028     -14030.028      252.95616      252.95616      47819.11       47819.11       97.944534      97.944534    
     83000  -13894.743     -13894.743     -14026.446     -14026.446      254.787        254.787        47832.377      47832.377      112.15818      112.15818    
Loop time of 337.403 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.723 hours/ns, 2.964 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.42     | 336.42     | 336.42     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15       | 0.15       | 0.15       |   0.0 |  0.04
Output  | 0.00023624 | 0.00023624 | 0.00023624 |   0.0 |  0.00
Modify  | 0.73569    | 0.73569    | 0.73569    |   0.0 |  0.22
Other   |            | 0.09798    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446706 ave      446706 max      446706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446706
Ave neighs/atom = 111.6765
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.483907151744, Press = 0.181508070326948
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -13894.743     -13894.743     -14026.446     -14026.446      254.787        254.787        47832.377      47832.377      112.15818      112.15818    
     84000  -13898.318     -13898.318     -14029.539     -14029.539      253.85713      253.85713      47796.098      47796.098      779.81754      779.81754    
Loop time of 335.918 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.311 hours/ns, 2.977 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 334.95     | 334.95     | 334.95     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14849    | 0.14849    | 0.14849    |   0.0 |  0.04
Output  | 0.00018853 | 0.00018853 | 0.00018853 |   0.0 |  0.00
Modify  | 0.72616    | 0.72616    | 0.72616    |   0.0 |  0.22
Other   |            | 0.09777    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445754 ave      445754 max      445754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445754
Ave neighs/atom = 111.4385
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.473365387691, Press = 0.00326171800256215
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -13898.318     -13898.318     -14029.539     -14029.539      253.85713      253.85713      47796.098      47796.098      779.81754      779.81754    
     85000  -13901.91      -13901.91      -14030.778     -14030.778      249.30567      249.30567      47794.953      47794.953      676.22401      676.22401    
Loop time of 338.214 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 93.948 hours/ns, 2.957 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.23     | 337.23     | 337.23     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15019    | 0.15019    | 0.15019    |   0.0 |  0.04
Output  | 0.00018802 | 0.00018802 | 0.00018802 |   0.0 |  0.00
Modify  | 0.73395    | 0.73395    | 0.73395    |   0.0 |  0.22
Other   |            | 0.09712    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447242 ave      447242 max      447242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447242
Ave neighs/atom = 111.8105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.459682322427, Press = -0.263736370829812
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -13901.91      -13901.91      -14030.778     -14030.778      249.30567      249.30567      47794.953      47794.953      676.22401      676.22401    
     86000  -13900.338     -13900.338     -14031.816     -14031.816      254.35226      254.35226      47817.459      47817.459     -28.021881     -28.021881    
Loop time of 340.653 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.626 hours/ns, 2.936 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.66     | 339.66     | 339.66     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14995    | 0.14995    | 0.14995    |   0.0 |  0.04
Output  | 0.00019012 | 0.00019012 | 0.00019012 |   0.0 |  0.00
Modify  | 0.74055    | 0.74055    | 0.74055    |   0.0 |  0.22
Other   |            | 0.09847    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447318 ave      447318 max      447318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447318
Ave neighs/atom = 111.8295
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.447932309826, Press = -0.572737986585902
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -13900.338     -13900.338     -14031.816     -14031.816      254.35226      254.35226      47817.459      47817.459     -28.021881     -28.021881    
     87000  -13899.798     -13899.798     -14027.54      -14027.54       247.12444      247.12444      47837.677      47837.677     -270.58318     -270.58318    
Loop time of 338.764 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.101 hours/ns, 2.952 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.78     | 337.78     | 337.78     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14923    | 0.14923    | 0.14923    |   0.0 |  0.04
Output  | 0.00025462 | 0.00025462 | 0.00025462 |   0.0 |  0.00
Modify  | 0.73495    | 0.73495    | 0.73495    |   0.0 |  0.22
Other   |            | 0.09784    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446550 ave      446550 max      446550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446550
Ave neighs/atom = 111.6375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.456299361437, Press = -0.355028352418778
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -13899.798     -13899.798     -14027.54      -14027.54       247.12444      247.12444      47837.677      47837.677     -270.58318     -270.58318    
     88000  -13894.399     -13894.399     -14026.412     -14026.412      255.38714      255.38714      47855.993      47855.993     -561.41605     -561.41605    
Loop time of 338.267 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 93.963 hours/ns, 2.956 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.28     | 337.28     | 337.28     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15048    | 0.15048    | 0.15048    |   0.0 |  0.04
Output  | 0.00026085 | 0.00026085 | 0.00026085 |   0.0 |  0.00
Modify  | 0.73458    | 0.73458    | 0.73458    |   0.0 |  0.22
Other   |            | 0.09879    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445654 ave      445654 max      445654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445654
Ave neighs/atom = 111.4135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.465766903826, Press = -0.0517113908108624
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -13894.399     -13894.399     -14026.412     -14026.412      255.38714      255.38714      47855.993      47855.993     -561.41605     -561.41605    
     89000  -13897.908     -13897.908     -14029.78      -14029.78       255.11526      255.11526      47846.239      47846.239     -609.71899     -609.71899    
Loop time of 340.589 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.608 hours/ns, 2.936 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.6      | 339.6      | 339.6      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15115    | 0.15115    | 0.15115    |   0.0 |  0.04
Output  | 0.00018665 | 0.00018665 | 0.00018665 |   0.0 |  0.00
Modify  | 0.73876    | 0.73876    | 0.73876    |   0.0 |  0.22
Other   |            | 0.09757    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445254 ave      445254 max      445254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445254
Ave neighs/atom = 111.3135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.468816061532, Press = -0.00510704038644889
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -13897.908     -13897.908     -14029.78      -14029.78       255.11526      255.11526      47846.239      47846.239     -609.71899     -609.71899    
     90000  -13898.544     -13898.544     -14029.721     -14029.721      253.76976      253.76976      47828.111      47828.111     -109.25149     -109.25149    
Loop time of 335.857 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.294 hours/ns, 2.977 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 334.88     | 334.88     | 334.88     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15114    | 0.15114    | 0.15114    |   0.0 |  0.05
Output  | 0.00018834 | 0.00018834 | 0.00018834 |   0.0 |  0.00
Modify  | 0.73166    | 0.73166    | 0.73166    |   0.0 |  0.22
Other   |            | 0.09798    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445786 ave      445786 max      445786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445786
Ave neighs/atom = 111.4465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.465234749741, Press = 0.0166499641127691
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     90000  -13898.544     -13898.544     -14029.721     -14029.721      253.76976      253.76976      47828.111      47828.111     -109.25149     -109.25149    
     91000  -13895.997     -13895.997     -14026.845     -14026.845      253.13453      253.13453      47843.771      47843.771     -352.51085     -352.51085    
Loop time of 337.571 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.770 hours/ns, 2.962 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.59     | 336.59     | 336.59     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14944    | 0.14944    | 0.14944    |   0.0 |  0.04
Output  | 0.00018717 | 0.00018717 | 0.00018717 |   0.0 |  0.00
Modify  | 0.73394    | 0.73394    | 0.73394    |   0.0 |  0.22
Other   |            | 0.09761    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446000 ave      446000 max      446000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446000
Ave neighs/atom = 111.5
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.469985108217, Press = 0.100950040826094
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     91000  -13895.997     -13895.997     -14026.845     -14026.845      253.13453      253.13453      47843.771      47843.771     -352.51085     -352.51085    
     92000  -13894.964     -13894.964     -14028.728     -14028.728      258.77707      258.77707      47860.076      47860.076     -905.42205     -905.42205    
Loop time of 338.69 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.081 hours/ns, 2.953 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.7      | 337.7      | 337.7      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15002    | 0.15002    | 0.15002    |   0.0 |  0.04
Output  | 0.00018794 | 0.00018794 | 0.00018794 |   0.0 |  0.00
Modify  | 0.74135    | 0.74135    | 0.74135    |   0.0 |  0.22
Other   |            | 0.09824    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445288 ave      445288 max      445288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445288
Ave neighs/atom = 111.322
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.470515030992, Press = 0.147218573163135
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     92000  -13894.964     -13894.964     -14028.728     -14028.728      258.77707      258.77707      47860.076      47860.076     -905.42205     -905.42205    
     93000  -13899.219     -13899.219     -14029.672     -14029.672      252.37034      252.37034      47867.137      47867.137     -1360.0073     -1360.0073    
Loop time of 335.941 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.317 hours/ns, 2.977 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 334.97     | 334.97     | 334.97     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14948    | 0.14948    | 0.14948    |   0.0 |  0.04
Output  | 0.00026901 | 0.00026901 | 0.00026901 |   0.0 |  0.00
Modify  | 0.72536    | 0.72536    | 0.72536    |   0.0 |  0.22
Other   |            | 0.09723    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445040 ave      445040 max      445040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445040
Ave neighs/atom = 111.26
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.486176612447, Press = 0.173559673564611
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -13899.219     -13899.219     -14029.672     -14029.672      252.37034      252.37034      47867.137      47867.137     -1360.0073     -1360.0073    
     94000  -13894.792     -13894.792     -14025.606     -14025.606      253.0678       253.0678       47856.193      47856.193     -535.56216     -535.56216    
Loop time of 337.11 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.642 hours/ns, 2.966 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.13     | 336.13     | 336.13     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14976    | 0.14976    | 0.14976    |   0.0 |  0.04
Output  | 0.0001868  | 0.0001868  | 0.0001868  |   0.0 |  0.00
Modify  | 0.73194    | 0.73194    | 0.73194    |   0.0 |  0.22
Other   |            | 0.09782    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444540 ave      444540 max      444540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444540
Ave neighs/atom = 111.135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.496093070256, Press = 0.521206484782483
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -13894.792     -13894.792     -14025.606     -14025.606      253.0678       253.0678       47856.193      47856.193     -535.56216     -535.56216    
     95000  -13901.074     -13901.074     -14030.108     -14030.108      249.6256       249.6256       47812.551      47812.551      242.89544      242.89544    
Loop time of 334.153 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.259 ns/day, 92.820 hours/ns, 2.993 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 333.18     | 333.18     | 333.18     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14871    | 0.14871    | 0.14871    |   0.0 |  0.04
Output  | 0.00023864 | 0.00023864 | 0.00023864 |   0.0 |  0.00
Modify  | 0.72174    | 0.72174    | 0.72174    |   0.0 |  0.22
Other   |            | 0.09736    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445100 ave      445100 max      445100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445100
Ave neighs/atom = 111.275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.497165926909, Press = 0.502160012869341
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -13901.074     -13901.074     -14030.108     -14030.108      249.6256       249.6256       47812.551      47812.551      242.89544      242.89544    
     96000  -13897.047     -13897.047     -14028.386     -14028.386      254.08425      254.08425      47825.411      47825.411      124.1088       124.1088     
Loop time of 340.217 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.505 hours/ns, 2.939 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.23     | 339.23     | 339.23     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14955    | 0.14955    | 0.14955    |   0.0 |  0.04
Output  | 0.00019006 | 0.00019006 | 0.00019006 |   0.0 |  0.00
Modify  | 0.73562    | 0.73562    | 0.73562    |   0.0 |  0.22
Other   |            | 0.09785    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446696 ave      446696 max      446696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446696
Ave neighs/atom = 111.674
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.48126335866, Press = 0.305228980720276
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -13897.047     -13897.047     -14028.386     -14028.386      254.08425      254.08425      47825.411      47825.411      124.1088       124.1088     
     97000  -13899.765     -13899.765     -14029.883     -14029.883      251.72264      251.72264      47818.959      47818.959      85.184993      85.184993    
Loop time of 339.779 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.383 hours/ns, 2.943 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.79     | 338.79     | 338.79     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15078    | 0.15078    | 0.15078    |   0.0 |  0.04
Output  | 0.00018817 | 0.00018817 | 0.00018817 |   0.0 |  0.00
Modify  | 0.73596    | 0.73596    | 0.73596    |   0.0 |  0.22
Other   |            | 0.09819    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446314 ave      446314 max      446314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446314
Ave neighs/atom = 111.5785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.471046663333, Press = -0.00315209860492007
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     97000  -13899.765     -13899.765     -14029.883     -14029.883      251.72264      251.72264      47818.959      47818.959      85.184993      85.184993    
     98000  -13900.816     -13900.816     -14030.572     -14030.572      251.02177      251.02177      47830.308      47830.308     -264.56825     -264.56825    
Loop time of 338.608 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.058 hours/ns, 2.953 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.63     | 337.63     | 337.63     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1505     | 0.1505     | 0.1505     |   0.0 |  0.04
Output  | 0.00019052 | 0.00019052 | 0.00019052 |   0.0 |  0.00
Modify  | 0.73226    | 0.73226    | 0.73226    |   0.0 |  0.22
Other   |            | 0.09798    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446328 ave      446328 max      446328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446328
Ave neighs/atom = 111.582
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.442335703308, Press = 0.0548780941733069
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -13900.816     -13900.816     -14030.572     -14030.572      251.02177      251.02177      47830.308      47830.308     -264.56825     -264.56825    
     99000  -13897.931     -13897.931     -14028.707     -14028.707      252.99635      252.99635      47843.564      47843.564     -433.07255     -433.07255    
Loop time of 340.053 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.459 hours/ns, 2.941 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.06     | 339.06     | 339.06     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15075    | 0.15075    | 0.15075    |   0.0 |  0.04
Output  | 0.00019019 | 0.00019019 | 0.00019019 |   0.0 |  0.00
Modify  | 0.742      | 0.742      | 0.742      |   0.0 |  0.22
Other   |            | 0.09868    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446086 ave      446086 max      446086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446086
Ave neighs/atom = 111.5215
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.434688035955, Press = -0.0444542336903888
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -13897.931     -13897.931     -14028.707     -14028.707      252.99635      252.99635      47843.564      47843.564     -433.07255     -433.07255    
    100000  -13900.537     -13900.537     -14028.854     -14028.854      248.23714      248.23714      47861.11       47861.11      -994.74562     -994.74562    
Loop time of 342.364 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.101 hours/ns, 2.921 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 341.37     | 341.37     | 341.37     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15165    | 0.15165    | 0.15165    |   0.0 |  0.04
Output  | 0.00048673 | 0.00048673 | 0.00048673 |   0.0 |  0.00
Modify  | 0.74509    | 0.74509    | 0.74509    |   0.0 |  0.22
Other   |            | 0.0975     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445724 ave      445724 max      445724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445724
Ave neighs/atom = 111.431
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.433755018867, Press = 0.127304271009023
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    100000  -13900.537     -13900.537     -14028.854     -14028.854      248.23714      248.23714      47861.11       47861.11      -994.74562     -994.74562    
    101000  -13896.387     -13896.387     -14027.809     -14027.809      254.24551      254.24551      47870.167      47870.167     -1170.2891     -1170.2891    
Loop time of 339.055 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.182 hours/ns, 2.949 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.07     | 338.07     | 338.07     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15089    | 0.15089    | 0.15089    |   0.0 |  0.04
Output  | 0.00022976 | 0.00022976 | 0.00022976 |   0.0 |  0.00
Modify  | 0.74082    | 0.74082    | 0.74082    |   0.0 |  0.22
Other   |            | 0.09832    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445066 ave      445066 max      445066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445066
Ave neighs/atom = 111.2665
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.422437351566, Press = 0.354544304800719
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -13896.387     -13896.387     -14027.809     -14027.809      254.24551      254.24551      47870.167      47870.167     -1170.2891     -1170.2891    
    102000  -13900.997     -13900.997     -14032.127     -14032.127      253.67928      253.67928      47828.291      47828.291     -424.79568     -424.79568    
Loop time of 341.173 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.770 hours/ns, 2.931 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 340.17     | 340.17     | 340.17     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15104    | 0.15104    | 0.15104    |   0.0 |  0.04
Output  | 0.00018994 | 0.00018994 | 0.00018994 |   0.0 |  0.00
Modify  | 0.74911    | 0.74911    | 0.74911    |   0.0 |  0.22
Other   |            | 0.09963    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444130 ave      444130 max      444130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444130
Ave neighs/atom = 111.0325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.402071393383, Press = 0.439503052454275
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    102000  -13900.997     -13900.997     -14032.127     -14032.127      253.67928      253.67928      47828.291      47828.291     -424.79568     -424.79568    
    103000  -13898.267     -13898.267     -14027.439     -14027.439      249.89175      249.89175      47823.324      47823.324      254.01404      254.01404    
Loop time of 337.456 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.738 hours/ns, 2.963 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.48     | 336.48     | 336.48     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14901    | 0.14901    | 0.14901    |   0.0 |  0.04
Output  | 0.00023525 | 0.00023525 | 0.00023525 |   0.0 |  0.00
Modify  | 0.73362    | 0.73362    | 0.73362    |   0.0 |  0.22
Other   |            | 0.09822    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446158 ave      446158 max      446158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446158
Ave neighs/atom = 111.5395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.391109095449, Press = 0.400804587813832
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    103000  -13898.267     -13898.267     -14027.439     -14027.439      249.89175      249.89175      47823.324      47823.324      254.01404      254.01404    
    104000  -13894.748     -13894.748     -14026.396     -14026.396      254.68048      254.68048      47808.508      47808.508      899.98039      899.98039    
Loop time of 341.186 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.774 hours/ns, 2.931 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 340.2      | 340.2      | 340.2      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14951    | 0.14951    | 0.14951    |   0.0 |  0.04
Output  | 0.00018722 | 0.00018722 | 0.00018722 |   0.0 |  0.00
Modify  | 0.73746    | 0.73746    | 0.73746    |   0.0 |  0.22
Other   |            | 0.09784    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446020 ave      446020 max      446020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446020
Ave neighs/atom = 111.505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.385115229205, Press = 0.118439292205894
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    104000  -13894.748     -13894.748     -14026.396     -14026.396      254.68048      254.68048      47808.508      47808.508      899.98039      899.98039    
    105000  -13899.371     -13899.371     -14030.762     -14030.762      254.18434      254.18434      47816.172      47816.172      135.54772      135.54772    
Loop time of 340.549 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.597 hours/ns, 2.936 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.56     | 339.56     | 339.56     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15092    | 0.15092    | 0.15092    |   0.0 |  0.04
Output  | 0.00022472 | 0.00022472 | 0.00022472 |   0.0 |  0.00
Modify  | 0.73978    | 0.73978    | 0.73978    |   0.0 |  0.22
Other   |            | 0.09808    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446826 ave      446826 max      446826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446826
Ave neighs/atom = 111.7065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.391656594773, Press = -0.107400165580958
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    105000  -13899.371     -13899.371     -14030.762     -14030.762      254.18434      254.18434      47816.172      47816.172      135.54772      135.54772    
    106000  -13896.77      -13896.77      -14025.969     -14025.969      249.94421      249.94421      47816.592      47816.592      556.67595      556.67595    
Loop time of 335.915 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.310 hours/ns, 2.977 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 334.95     | 334.95     | 334.95     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14966    | 0.14966    | 0.14966    |   0.0 |  0.04
Output  | 0.00024089 | 0.00024089 | 0.00024089 |   0.0 |  0.00
Modify  | 0.7227     | 0.7227     | 0.7227     |   0.0 |  0.22
Other   |            | 0.09692    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446682 ave      446682 max      446682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446682
Ave neighs/atom = 111.6705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.401526868104, Press = -0.187366967109175
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    106000  -13896.77      -13896.77      -14025.969     -14025.969      249.94421      249.94421      47816.592      47816.592      556.67595      556.67595    
    107000  -13899.693     -13899.693     -14028.323     -14028.323      248.84316      248.84316      47819.408      47819.408      159.86488      159.86488    
Loop time of 337.716 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.810 hours/ns, 2.961 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.74     | 336.74     | 336.74     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15095    | 0.15095    | 0.15095    |   0.0 |  0.04
Output  | 0.00023702 | 0.00023702 | 0.00023702 |   0.0 |  0.00
Modify  | 0.73097    | 0.73097    | 0.73097    |   0.0 |  0.22
Other   |            | 0.09698    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446726 ave      446726 max      446726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446726
Ave neighs/atom = 111.6815
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.409314561553, Press = -0.0817229271708143
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    107000  -13899.693     -13899.693     -14028.323     -14028.323      248.84316      248.84316      47819.408      47819.408      159.86488      159.86488    
    108000  -13896.861     -13896.861     -14028.368     -14028.368      254.41035      254.41035      47818.828      47818.828      345.95588      345.95588    
Loop time of 339.189 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.219 hours/ns, 2.948 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.19     | 338.19     | 338.19     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15045    | 0.15045    | 0.15045    |   0.0 |  0.04
Output  | 0.00018884 | 0.00018884 | 0.00018884 |   0.0 |  0.00
Modify  | 0.74631    | 0.74631    | 0.74631    |   0.0 |  0.22
Other   |            | 0.09901    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446164 ave      446164 max      446164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446164
Ave neighs/atom = 111.541
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.420826198041, Press = -0.223364575359005
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    108000  -13896.861     -13896.861     -14028.368     -14028.368      254.41035      254.41035      47818.828      47818.828      345.95588      345.95588    
    109000  -13895.555     -13895.555     -14029.635     -14029.635      259.38635      259.38635      47838.379      47838.379     -359.02595     -359.02595    
Loop time of 341.506 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.863 hours/ns, 2.928 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 340.51     | 340.51     | 340.51     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15149    | 0.15149    | 0.15149    |   0.0 |  0.04
Output  | 0.00018702 | 0.00018702 | 0.00018702 |   0.0 |  0.00
Modify  | 0.74764    | 0.74764    | 0.74764    |   0.0 |  0.22
Other   |            | 0.09835    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446328 ave      446328 max      446328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446328
Ave neighs/atom = 111.582
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.417174878854, Press = -0.267187109097472
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    109000  -13895.555     -13895.555     -14029.635     -14029.635      259.38635      259.38635      47838.379      47838.379     -359.02595     -359.02595    
    110000  -13899.433     -13899.433     -14029.636     -14029.636      251.88757      251.88757      47852.014      47852.014     -943.03556     -943.03556    
Loop time of 340.396 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.554 hours/ns, 2.938 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.41     | 339.41     | 339.41     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1492     | 0.1492     | 0.1492     |   0.0 |  0.04
Output  | 0.00027744 | 0.00027744 | 0.00027744 |   0.0 |  0.00
Modify  | 0.73639    | 0.73639    | 0.73639    |   0.0 |  0.22
Other   |            | 0.09757    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445968 ave      445968 max      445968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445968
Ave neighs/atom = 111.492
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.400718749868, Press = -0.405725531969339
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    110000  -13899.433     -13899.433     -14029.636     -14029.636      251.88757      251.88757      47852.014      47852.014     -943.03556     -943.03556    
    111000  -13898.028     -13898.028     -14027.575     -14027.575      250.61765      250.61765      47867.306      47867.306     -1088.7625     -1088.7625    
Loop time of 342.374 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.104 hours/ns, 2.921 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 341.38     | 341.38     | 341.38     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15222    | 0.15222    | 0.15222    |   0.0 |  0.04
Output  | 0.00019086 | 0.00019086 | 0.00019086 |   0.0 |  0.00
Modify  | 0.74591    | 0.74591    | 0.74591    |   0.0 |  0.22
Other   |            | 0.09976    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445100 ave      445100 max      445100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445100
Ave neighs/atom = 111.275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.385537857282, Press = -0.273465910296318
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    111000  -13898.028     -13898.028     -14027.575     -14027.575      250.61765      250.61765      47867.306      47867.306     -1088.7625     -1088.7625    
    112000  -13900.563     -13900.563     -14031.617     -14031.617      253.53364      253.53364      47871.476      47871.476     -1638.5253     -1638.5253    
Loop time of 339.871 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.408 hours/ns, 2.942 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.87     | 338.87     | 338.87     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15103    | 0.15103    | 0.15103    |   0.0 |  0.04
Output  | 0.00022716 | 0.00022716 | 0.00022716 |   0.0 |  0.00
Modify  | 0.74679    | 0.74679    | 0.74679    |   0.0 |  0.22
Other   |            | 0.09897    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444332 ave      444332 max      444332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444332
Ave neighs/atom = 111.083
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.392079916827, Press = -0.138633557489953
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    112000  -13900.563     -13900.563     -14031.617     -14031.617      253.53364      253.53364      47871.476      47871.476     -1638.5253     -1638.5253    
    113000  -13892.839     -13892.839     -14025.523     -14025.523      256.68602      256.68602      47875.124      47875.124     -961.80496     -961.80496    
Loop time of 343 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.278 hours/ns, 2.915 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 342        | 342        | 342        |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15234    | 0.15234    | 0.15234    |   0.0 |  0.04
Output  | 0.00024138 | 0.00024138 | 0.00024138 |   0.0 |  0.00
Modify  | 0.74999    | 0.74999    | 0.74999    |   0.0 |  0.22
Other   |            | 0.09892    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444660 ave      444660 max      444660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444660
Ave neighs/atom = 111.165
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.394720789838, Press = 0.083839078303096
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    113000  -13892.839     -13892.839     -14025.523     -14025.523      256.68602      256.68602      47875.124      47875.124     -961.80496     -961.80496    
    114000  -13900.166     -13900.166     -14029.378     -14029.378      249.96866      249.96866      47838.523      47838.523     -336.28493     -336.28493    
Loop time of 343.876 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.251 ns/day, 95.521 hours/ns, 2.908 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 342.87     | 342.87     | 342.87     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1522     | 0.1522     | 0.1522     |   0.0 |  0.04
Output  | 0.00018864 | 0.00018864 | 0.00018864 |   0.0 |  0.00
Modify  | 0.75522    | 0.75522    | 0.75522    |   0.0 |  0.22
Other   |            | 0.09944    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444206 ave      444206 max      444206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444206
Ave neighs/atom = 111.0515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.402361544999, Press = 0.0642917204997249
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    114000  -13900.166     -13900.166     -14029.378     -14029.378      249.96866      249.96866      47838.523      47838.523     -336.28493     -336.28493    
    115000  -13902.005     -13902.005     -14030.769     -14030.769      249.10225      249.10225      47821.264      47821.264     -42.951969     -42.951969    
Loop time of 343.777 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.251 ns/day, 95.494 hours/ns, 2.909 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 342.77     | 342.77     | 342.77     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15336    | 0.15336    | 0.15336    |   0.0 |  0.04
Output  | 0.00018906 | 0.00018906 | 0.00018906 |   0.0 |  0.00
Modify  | 0.75408    | 0.75408    | 0.75408    |   0.0 |  0.22
Other   |            | 0.0986     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445882 ave      445882 max      445882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445882
Ave neighs/atom = 111.4705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.397857318313, Press = 0.151737315371107
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    115000  -13902.005     -13902.005     -14030.769     -14030.769      249.10225      249.10225      47821.264      47821.264     -42.951969     -42.951969    
    116000  -13898.072     -13898.072     -14027.37      -14027.37       250.13588      250.13588      47801.322      47801.322      949.54936      949.54936    
Loop time of 339.563 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.323 hours/ns, 2.945 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.58     | 338.58     | 338.58     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14873    | 0.14873    | 0.14873    |   0.0 |  0.04
Output  | 0.00019256 | 0.00019256 | 0.00019256 |   0.0 |  0.00
Modify  | 0.73234    | 0.73234    | 0.73234    |   0.0 |  0.22
Other   |            | 0.09818    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446630 ave      446630 max      446630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446630
Ave neighs/atom = 111.6575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.380971547147, Press = 0.212741815965485
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    116000  -13898.072     -13898.072     -14027.37      -14027.37       250.13588      250.13588      47801.322      47801.322      949.54936      949.54936    
    117000  -13899.557     -13899.557     -14028.72      -14028.72       249.87495      249.87495      47750.589      47750.589      2234.3504      2234.3504    
Loop time of 338.274 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 93.965 hours/ns, 2.956 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.29     | 337.29     | 337.29     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15013    | 0.15013    | 0.15013    |   0.0 |  0.04
Output  | 0.00019972 | 0.00019972 | 0.00019972 |   0.0 |  0.00
Modify  | 0.73354    | 0.73354    | 0.73354    |   0.0 |  0.22
Other   |            | 0.09724    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447044 ave      447044 max      447044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447044
Ave neighs/atom = 111.761
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.378451940691, Press = 0.187737016834136
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    117000  -13899.557     -13899.557     -14028.72      -14028.72       249.87495      249.87495      47750.589      47750.589      2234.3504      2234.3504    
    118000  -13895.769     -13895.769     -14029.278     -14029.278      258.28322      258.28322      47771.12       47771.12       1748.2662      1748.2662    
Loop time of 343.2 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.333 hours/ns, 2.914 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 342.21     | 342.21     | 342.21     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15128    | 0.15128    | 0.15128    |   0.0 |  0.04
Output  | 0.00018884 | 0.00018884 | 0.00018884 |   0.0 |  0.00
Modify  | 0.73927    | 0.73927    | 0.73927    |   0.0 |  0.22
Other   |            | 0.09891    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       449346 ave      449346 max      449346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 449346
Ave neighs/atom = 112.3365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.382082596758, Press = -0.0453884177948846
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    118000  -13895.769     -13895.769     -14029.278     -14029.278      258.28322      258.28322      47771.12       47771.12       1748.2662      1748.2662    
    119000  -13900.522     -13900.522     -14031.538     -14031.538      253.45938      253.45938      47772.898      47772.898      1235.4654      1235.4654    
Loop time of 342.989 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.275 hours/ns, 2.916 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 341.99     | 341.99     | 341.99     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15217    | 0.15217    | 0.15217    |   0.0 |  0.04
Output  | 0.00018862 | 0.00018862 | 0.00018862 |   0.0 |  0.00
Modify  | 0.74747    | 0.74747    | 0.74747    |   0.0 |  0.22
Other   |            | 0.09796    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       448260 ave      448260 max      448260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 448260
Ave neighs/atom = 112.065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.396910698295, Press = -0.129655772375145
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    119000  -13900.522     -13900.522     -14031.538     -14031.538      253.45938      253.45938      47772.898      47772.898      1235.4654      1235.4654    
    120000  -13897.142     -13897.142     -14028.06      -14028.06       253.27054      253.27054      47793.715      47793.715      936.92051      936.92051    
Loop time of 341.507 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.863 hours/ns, 2.928 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 340.51     | 340.51     | 340.51     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15112    | 0.15112    | 0.15112    |   0.0 |  0.04
Output  | 0.00023501 | 0.00023501 | 0.00023501 |   0.0 |  0.00
Modify  | 0.743      | 0.743      | 0.743      |   0.0 |  0.22
Other   |            | 0.09836    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       448148 ave      448148 max      448148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 448148
Ave neighs/atom = 112.037
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.393217040537, Press = -0.19301576273713
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    120000  -13897.142     -13897.142     -14028.06      -14028.06       253.27054      253.27054      47793.715      47793.715      936.92051      936.92051    
    121000  -13900.877     -13900.877     -14029.855     -14029.855      249.51697      249.51697      47804.413      47804.413      546.03154      546.03154    
Loop time of 339.878 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.410 hours/ns, 2.942 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.88     | 338.88     | 338.88     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15158    | 0.15158    | 0.15158    |   0.0 |  0.04
Output  | 0.00023272 | 0.00023272 | 0.00023272 |   0.0 |  0.00
Modify  | 0.74249    | 0.74249    | 0.74249    |   0.0 |  0.22
Other   |            | 0.09904    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447296 ave      447296 max      447296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447296
Ave neighs/atom = 111.824
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.388909325081, Press = -0.253314266155332
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    121000  -13900.877     -13900.877     -14029.855     -14029.855      249.51697      249.51697      47804.413      47804.413      546.03154      546.03154    
    122000  -13897.633     -13897.633     -14026.388     -14026.388      249.08425      249.08425      47803.304      47803.304      942.53676      942.53676    
Loop time of 340.864 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.684 hours/ns, 2.934 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.87     | 339.87     | 339.87     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14946    | 0.14946    | 0.14946    |   0.0 |  0.04
Output  | 0.00018863 | 0.00018863 | 0.00018863 |   0.0 |  0.00
Modify  | 0.74253    | 0.74253    | 0.74253    |   0.0 |  0.22
Other   |            | 0.09887    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446904 ave      446904 max      446904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446904
Ave neighs/atom = 111.726
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.372642321836, Press = -0.310951421540904
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    122000  -13897.633     -13897.633     -14026.388     -14026.388      249.08425      249.08425      47803.304      47803.304      942.53676      942.53676    
    123000  -13895.903     -13895.903     -14027.185     -14027.185      253.97404      253.97404      47828.67       47828.67       148.68168      148.68168    
Loop time of 338.986 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.163 hours/ns, 2.950 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338        | 338        | 338        |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15062    | 0.15062    | 0.15062    |   0.0 |  0.04
Output  | 0.00018876 | 0.00018876 | 0.00018876 |   0.0 |  0.00
Modify  | 0.7361     | 0.7361     | 0.7361     |   0.0 |  0.22
Other   |            | 0.09777    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447168 ave      447168 max      447168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447168
Ave neighs/atom = 111.792
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.370377461782, Press = -0.278948735107461
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    123000  -13895.903     -13895.903     -14027.185     -14027.185      253.97404      253.97404      47828.67       47828.67       148.68168      148.68168    
    124000  -13898.696     -13898.696     -14029.009     -14029.009      252.09932      252.09932      47835.022      47835.022     -296.28838     -296.28838    
Loop time of 339.413 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.281 hours/ns, 2.946 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.42     | 338.42     | 338.42     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15292    | 0.15292    | 0.15292    |   0.0 |  0.05
Output  | 0.00019284 | 0.00019284 | 0.00019284 |   0.0 |  0.00
Modify  | 0.74073    | 0.74073    | 0.74073    |   0.0 |  0.22
Other   |            | 0.09967    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446398 ave      446398 max      446398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446398
Ave neighs/atom = 111.5995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.368597131562, Press = -0.0955751360378519
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    124000  -13898.696     -13898.696     -14029.009     -14029.009      252.09932      252.09932      47835.022      47835.022     -296.28838     -296.28838    
    125000  -13898.754     -13898.754     -14029.56      -14029.56       253.0528       253.0528       47828.971      47828.971     -170.42691     -170.42691    
Loop time of 343.234 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.343 hours/ns, 2.913 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 342.22     | 342.22     | 342.22     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15248    | 0.15248    | 0.15248    |   0.0 |  0.04
Output  | 0.00018964 | 0.00018964 | 0.00018964 |   0.0 |  0.00
Modify  | 0.75706    | 0.75706    | 0.75706    |   0.0 |  0.22
Other   |            | 0.1002     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445252 ave      445252 max      445252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445252
Ave neighs/atom = 111.313
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.380147485941, Press = -0.0237366941371834
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    125000  -13898.754     -13898.754     -14029.56      -14029.56       253.0528       253.0528       47828.971      47828.971     -170.42691     -170.42691    
    126000  -13894.05      -13894.05      -14026.517     -14026.517      256.26635      256.26635      47826.299      47826.299      384.53152      384.53152    
Loop time of 343.224 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.340 hours/ns, 2.914 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 342.23     | 342.23     | 342.23     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15115    | 0.15115    | 0.15115    |   0.0 |  0.04
Output  | 0.00018894 | 0.00018894 | 0.00018894 |   0.0 |  0.00
Modify  | 0.74476    | 0.74476    | 0.74476    |   0.0 |  0.22
Other   |            | 0.09906    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446056 ave      446056 max      446056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446056
Ave neighs/atom = 111.514
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.383117556476, Press = -0.112707021213031
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    126000  -13894.05      -13894.05      -14026.517     -14026.517      256.26635      256.26635      47826.299      47826.299      384.53152      384.53152    
    127000  -13898.867     -13898.867     -14028.733     -14028.733      251.23403      251.23403      47830.126      47830.126      30.472037      30.472037    
Loop time of 341.2 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.778 hours/ns, 2.931 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 340.21     | 340.21     | 340.21     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15063    | 0.15063    | 0.15063    |   0.0 |  0.04
Output  | 0.00019008 | 0.00019008 | 0.00019008 |   0.0 |  0.00
Modify  | 0.7437     | 0.7437     | 0.7437     |   0.0 |  0.22
Other   |            | 0.09799    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446374 ave      446374 max      446374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446374
Ave neighs/atom = 111.5935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.394532880219, Press = -0.336901098003274
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    127000  -13898.867     -13898.867     -14028.733     -14028.733      251.23403      251.23403      47830.126      47830.126      30.472037      30.472037    
    128000  -13893.718     -13893.718     -14026.953     -14026.953      257.75087      257.75087      47895.637      47895.637     -1740.2521     -1740.2521    
Loop time of 337.577 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.771 hours/ns, 2.962 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 336.6      | 336.6      | 336.6      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15053    | 0.15053    | 0.15053    |   0.0 |  0.04
Output  | 0.00023968 | 0.00023968 | 0.00023968 |   0.0 |  0.00
Modify  | 0.73157    | 0.73157    | 0.73157    |   0.0 |  0.22
Other   |            | 0.09798    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446232 ave      446232 max      446232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446232
Ave neighs/atom = 111.558
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.399758304204, Press = -0.427543777445661
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    128000  -13893.718     -13893.718     -14026.953     -14026.953      257.75087      257.75087      47895.637      47895.637     -1740.2521     -1740.2521    
    129000  -13898.551     -13898.551     -14027.85      -14027.85       250.13746      250.13746      47866.045      47866.045     -1038.4414     -1038.4414    
Loop time of 334.318 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.258 ns/day, 92.866 hours/ns, 2.991 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 333.35     | 333.35     | 333.35     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14894    | 0.14894    | 0.14894    |   0.0 |  0.04
Output  | 0.00023182 | 0.00023182 | 0.00023182 |   0.0 |  0.00
Modify  | 0.72598    | 0.72598    | 0.72598    |   0.0 |  0.22
Other   |            | 0.09669    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       443370 ave      443370 max      443370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 443370
Ave neighs/atom = 110.8425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.405406282373, Press = -0.0468908293222487
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    129000  -13898.551     -13898.551     -14027.85      -14027.85       250.13746      250.13746      47866.045      47866.045     -1038.4414     -1038.4414    
    130000  -13896.73      -13896.73      -14027.716     -14027.716      253.40149      253.40149      47866.48       47866.48      -1049.0578     -1049.0578    
Loop time of 340.312 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.531 hours/ns, 2.938 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.33     | 339.33     | 339.33     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15034    | 0.15034    | 0.15034    |   0.0 |  0.04
Output  | 0.00018804 | 0.00018804 | 0.00018804 |   0.0 |  0.00
Modify  | 0.73674    | 0.73674    | 0.73674    |   0.0 |  0.22
Other   |            | 0.09799    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444580 ave      444580 max      444580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444580
Ave neighs/atom = 111.145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.415823685391, Press = 0.0541105546739478
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    130000  -13896.73      -13896.73      -14027.716     -14027.716      253.40149      253.40149      47866.48       47866.48      -1049.0578     -1049.0578    
    131000  -13898.558     -13898.558     -14028.454     -14028.454      251.29218      251.29218      47840.742      47840.742     -480.27991     -480.27991    
Loop time of 336.459 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.461 hours/ns, 2.972 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 335.47     | 335.47     | 335.47     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1503     | 0.1503     | 0.1503     |   0.0 |  0.04
Output  | 0.00019104 | 0.00019104 | 0.00019104 |   0.0 |  0.00
Modify  | 0.73586    | 0.73586    | 0.73586    |   0.0 |  0.22
Other   |            | 0.09837    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444830 ave      444830 max      444830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444830
Ave neighs/atom = 111.2075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.410799662334, Press = 0.190366145915726
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    131000  -13898.558     -13898.558     -14028.454     -14028.454      251.29218      251.29218      47840.742      47840.742     -480.27991     -480.27991    
    132000  -13900.932     -13900.932     -14030.076     -14030.076      249.83635      249.83635      47833.506      47833.506     -450.08517     -450.08517    
Loop time of 336.723 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.257 ns/day, 93.534 hours/ns, 2.970 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 335.74     | 335.74     | 335.74     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14931    | 0.14931    | 0.14931    |   0.0 |  0.04
Output  | 0.00018808 | 0.00018808 | 0.00018808 |   0.0 |  0.00
Modify  | 0.73383    | 0.73383    | 0.73383    |   0.0 |  0.22
Other   |            | 0.09733    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445552 ave      445552 max      445552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445552
Ave neighs/atom = 111.388
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.407593833103, Press = 0.227785747992161
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    132000  -13900.932     -13900.932     -14030.076     -14030.076      249.83635      249.83635      47833.506      47833.506     -450.08517     -450.08517    
    133000  -13898.469     -13898.469     -14029.532     -14029.532      253.54931      253.54931      47827.878      47827.878     -72.396707     -72.396707    
Loop time of 340.51 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.586 hours/ns, 2.937 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.51     | 339.51     | 339.51     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15157    | 0.15157    | 0.15157    |   0.0 |  0.04
Output  | 0.00018765 | 0.00018765 | 0.00018765 |   0.0 |  0.00
Modify  | 0.74754    | 0.74754    | 0.74754    |   0.0 |  0.22
Other   |            | 0.09813    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445926 ave      445926 max      445926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445926
Ave neighs/atom = 111.4815
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.406365899091, Press = 0.259866616489088
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    133000  -13898.469     -13898.469     -14029.532     -14029.532      253.54931      253.54931      47827.878      47827.878     -72.396707     -72.396707    
    134000  -13900.335     -13900.335     -14031.123     -14031.123      253.01847      253.01847      47800.524      47800.524      602.96102      602.96102    
Loop time of 343.055 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.293 hours/ns, 2.915 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 342.05     | 342.05     | 342.05     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15269    | 0.15269    | 0.15269    |   0.0 |  0.04
Output  | 0.00018704 | 0.00018704 | 0.00018704 |   0.0 |  0.00
Modify  | 0.75331    | 0.75331    | 0.75331    |   0.0 |  0.22
Other   |            | 0.09946    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446438 ave      446438 max      446438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446438
Ave neighs/atom = 111.6095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.390185618676, Press = 0.217437814411917
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    134000  -13900.335     -13900.335     -14031.123     -14031.123      253.01847      253.01847      47800.524      47800.524      602.96102      602.96102    
    135000  -13895.369     -13895.369     -14028.213     -14028.213      256.99575      256.99575      47792.675      47792.675      1174.7598      1174.7598    
Loop time of 342.512 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.142 hours/ns, 2.920 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 341.52     | 341.52     | 341.52     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15115    | 0.15115    | 0.15115    |   0.0 |  0.04
Output  | 0.00018628 | 0.00018628 | 0.00018628 |   0.0 |  0.00
Modify  | 0.74479    | 0.74479    | 0.74479    |   0.0 |  0.22
Other   |            | 0.09876    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447526 ave      447526 max      447526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447526
Ave neighs/atom = 111.8815
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.383708810177, Press = 0.170813168759209
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    135000  -13895.369     -13895.369     -14028.213     -14028.213      256.99575      256.99575      47792.675      47792.675      1174.7598      1174.7598    
    136000  -13900.14      -13900.14      -14031.413     -14031.413      253.95738      253.95738      47755.172      47755.172      1771.6397      1771.6397    
Loop time of 345.815 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.250 ns/day, 96.060 hours/ns, 2.892 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 344.8      | 344.8      | 344.8      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15254    | 0.15254    | 0.15254    |   0.0 |  0.04
Output  | 0.00022967 | 0.00022967 | 0.00022967 |   0.0 |  0.00
Modify  | 0.76008    | 0.76008    | 0.76008    |   0.0 |  0.22
Other   |            | 0.09872    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447350 ave      447350 max      447350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447350
Ave neighs/atom = 111.8375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.389281804853, Press = 0.000168708183759024
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    136000  -13900.14      -13900.14      -14031.413     -14031.413      253.95738      253.95738      47755.172      47755.172      1771.6397      1771.6397    
    137000  -13898.449     -13898.449     -14029.879     -14029.879      254.2605       254.2605       47765.402      47765.402      1693.0157      1693.0157    
Loop time of 340.746 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.652 hours/ns, 2.935 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.75     | 339.75     | 339.75     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15145    | 0.15145    | 0.15145    |   0.0 |  0.04
Output  | 0.00018597 | 0.00018597 | 0.00018597 |   0.0 |  0.00
Modify  | 0.74065    | 0.74065    | 0.74065    |   0.0 |  0.22
Other   |            | 0.09876    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       448642 ave      448642 max      448642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 448642
Ave neighs/atom = 112.1605
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.386570616466, Press = -0.180602500827702
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    137000  -13898.449     -13898.449     -14029.879     -14029.879      254.2605       254.2605       47765.402      47765.402      1693.0157      1693.0157    
    138000  -13900.94      -13900.94      -14029.769     -14029.769      249.22893      249.22893      47797.217      47797.217      739.90446      739.90446    
Loop time of 343.054 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.293 hours/ns, 2.915 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 342.06     | 342.06     | 342.06     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15107    | 0.15107    | 0.15107    |   0.0 |  0.04
Output  | 0.00018859 | 0.00018859 | 0.00018859 |   0.0 |  0.00
Modify  | 0.74589    | 0.74589    | 0.74589    |   0.0 |  0.22
Other   |            | 0.09868    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       448196 ave      448196 max      448196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 448196
Ave neighs/atom = 112.049
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.368607347593, Press = -0.179269232749847
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    138000  -13900.94      -13900.94      -14029.769     -14029.769      249.22893      249.22893      47797.217      47797.217      739.90446      739.90446    
    139000  -13896.66      -13896.66      -14026.643     -14026.643      251.46223      251.46223      47827.237      47827.237      329.75259      329.75259    
Loop time of 342.766 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.213 hours/ns, 2.917 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 341.77     | 341.77     | 341.77     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15282    | 0.15282    | 0.15282    |   0.0 |  0.04
Output  | 0.00019371 | 0.00019371 | 0.00019371 |   0.0 |  0.00
Modify  | 0.7465     | 0.7465     | 0.7465     |   0.0 |  0.22
Other   |            | 0.09823    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       447110 ave      447110 max      447110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 447110
Ave neighs/atom = 111.7775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.365976713506, Press = -0.110175820476908
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    139000  -13896.66      -13896.66      -14026.643     -14026.643      251.46223      251.46223      47827.237      47827.237      329.75259      329.75259    
    140000  -13896.357     -13896.357     -14029.607     -14029.607      257.78109      257.78109      47846.487      47846.487     -621.96834     -621.96834    
Loop time of 345.038 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.250 ns/day, 95.844 hours/ns, 2.898 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 344.04     | 344.04     | 344.04     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15238    | 0.15238    | 0.15238    |   0.0 |  0.04
Output  | 0.0001883  | 0.0001883  | 0.0001883  |   0.0 |  0.00
Modify  | 0.75044    | 0.75044    | 0.75044    |   0.0 |  0.22
Other   |            | 0.09779    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446010 ave      446010 max      446010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446010
Ave neighs/atom = 111.5025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.36965556461, Press = -0.0887427257624507
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    140000  -13896.357     -13896.357     -14029.607     -14029.607      257.78109      257.78109      47846.487      47846.487     -621.96834     -621.96834    
    141000  -13901.365     -13901.365     -14030.999     -14030.999      250.78536      250.78536      47828.698      47828.698     -389.02952     -389.02952    
Loop time of 339.924 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.423 hours/ns, 2.942 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.93     | 338.93     | 338.93     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15116    | 0.15116    | 0.15116    |   0.0 |  0.04
Output  | 0.00018792 | 0.00018792 | 0.00018792 |   0.0 |  0.00
Modify  | 0.7431     | 0.7431     | 0.7431     |   0.0 |  0.22
Other   |            | 0.09857    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445242 ave      445242 max      445242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445242
Ave neighs/atom = 111.3105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.372369191884, Press = -0.119818213335534
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    141000  -13901.365     -13901.365     -14030.999     -14030.999      250.78536      250.78536      47828.698      47828.698     -389.02952     -389.02952    
    142000  -13896.174     -13896.174     -14029.382     -14029.382      257.70062      257.70062      47865.531      47865.531     -1107.0577     -1107.0577    
Loop time of 339.777 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.382 hours/ns, 2.943 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 338.79     | 338.79     | 338.79     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15021    | 0.15021    | 0.15021    |   0.0 |  0.04
Output  | 0.00030203 | 0.00030203 | 0.00030203 |   0.0 |  0.00
Modify  | 0.73762    | 0.73762    | 0.73762    |   0.0 |  0.22
Other   |            | 0.09844    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445950 ave      445950 max      445950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445950
Ave neighs/atom = 111.4875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.367933387744, Press = -0.233659988781766
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    142000  -13896.174     -13896.174     -14029.382     -14029.382      257.70062      257.70062      47865.531      47865.531     -1107.0577     -1107.0577    
    143000  -13899.809     -13899.809     -14028.873     -14028.873      249.68456      249.68456      47875.791      47875.791     -1393.1539     -1393.1539    
Loop time of 340.782 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.662 hours/ns, 2.934 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.79     | 339.79     | 339.79     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1515     | 0.1515     | 0.1515     |   0.0 |  0.04
Output  | 0.0001916  | 0.0001916  | 0.0001916  |   0.0 |  0.00
Modify  | 0.73945    | 0.73945    | 0.73945    |   0.0 |  0.22
Other   |            | 0.09903    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444904 ave      444904 max      444904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444904
Ave neighs/atom = 111.226
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.371429209645, Press = -0.203823004475215
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    143000  -13899.809     -13899.809     -14028.873     -14028.873      249.68456      249.68456      47875.791      47875.791     -1393.1539     -1393.1539    
    144000  -13900.254     -13900.254     -14029.454     -14029.454      249.94483      249.94483      47875.59       47875.59      -1410.3009     -1410.3009    
Loop time of 340.075 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.465 hours/ns, 2.941 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 339.08     | 339.08     | 339.08     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15073    | 0.15073    | 0.15073    |   0.0 |  0.04
Output  | 0.00023886 | 0.00023886 | 0.00023886 |   0.0 |  0.00
Modify  | 0.74236    | 0.74236    | 0.74236    |   0.0 |  0.22
Other   |            | 0.09825    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444148 ave      444148 max      444148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444148
Ave neighs/atom = 111.037
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.374598358872, Press = -0.217853329458632
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    144000  -13900.254     -13900.254     -14029.454     -14029.454      249.94483      249.94483      47875.59       47875.59      -1410.3009     -1410.3009    
    145000  -13898.314     -13898.314     -14028.342     -14028.342      251.54737      251.54737      47869.057      47869.057     -1124.0635     -1124.0635    
Loop time of 335.197 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.258 ns/day, 93.110 hours/ns, 2.983 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 334.22     | 334.22     | 334.22     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14936    | 0.14936    | 0.14936    |   0.0 |  0.04
Output  | 0.00018993 | 0.00018993 | 0.00018993 |   0.0 |  0.00
Modify  | 0.72845    | 0.72845    | 0.72845    |   0.0 |  0.22
Other   |            | 0.09736    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444540 ave      444540 max      444540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444540
Ave neighs/atom = 111.135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.361108792558, Press = -0.0859585491231412
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    145000  -13898.314     -13898.314     -14028.342     -14028.342      251.54737      251.54737      47869.057      47869.057     -1124.0635     -1124.0635    
    146000  -13898.688     -13898.688     -14029.961     -14029.961      253.95744      253.95744      47855.083      47855.083     -916.24384     -916.24384    
Loop time of 341.851 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.253 ns/day, 94.959 hours/ns, 2.925 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 340.85     | 340.85     | 340.85     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15182    | 0.15182    | 0.15182    |   0.0 |  0.04
Output  | 0.00018737 | 0.00018737 | 0.00018737 |   0.0 |  0.00
Modify  | 0.74718    | 0.74718    | 0.74718    |   0.0 |  0.22
Other   |            | 0.09846    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       444584 ave      444584 max      444584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 444584
Ave neighs/atom = 111.146
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.362641495053, Press = 0.0823989242883433
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    146000  -13898.688     -13898.688     -14029.961     -14029.961      253.95744      253.95744      47855.083      47855.083     -916.24384     -916.24384    
    147000  -13894.853     -13894.853     -14028.641     -14028.641      258.82164      258.82164      47850.786      47850.786     -589.88019     -589.88019    
Loop time of 344.255 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.251 ns/day, 95.626 hours/ns, 2.905 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 343.25     | 343.25     | 343.25     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15267    | 0.15267    | 0.15267    |   0.0 |  0.04
Output  | 0.0001886  | 0.0001886  | 0.0001886  |   0.0 |  0.00
Modify  | 0.75426    | 0.75426    | 0.75426    |   0.0 |  0.22
Other   |            | 0.09864    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445282 ave      445282 max      445282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445282
Ave neighs/atom = 111.3205
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.369955802835, Press = 0.0546188244041408
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    147000  -13894.853     -13894.853     -14028.641     -14028.641      258.82164      258.82164      47850.786      47850.786     -589.88019     -589.88019    
    148000  -13899.243     -13899.243     -14029.265     -14029.265      251.53641      251.53641      47823.062      47823.062      7.8942887      7.8942887    
Loop time of 342.533 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.148 hours/ns, 2.919 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 341.53     | 341.53     | 341.53     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15055    | 0.15055    | 0.15055    |   0.0 |  0.04
Output  | 0.00018872 | 0.00018872 | 0.00018872 |   0.0 |  0.00
Modify  | 0.75065    | 0.75065    | 0.75065    |   0.0 |  0.22
Other   |            | 0.09879    |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       445422 ave      445422 max      445422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 445422
Ave neighs/atom = 111.3555
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.364483913772, Press = 0.0405890784736175
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    148000  -13899.243     -13899.243     -14029.265     -14029.265      251.53641      251.53641      47823.062      47823.062      7.8942887      7.8942887    
    149000  -13900.437     -13900.437     -14031.575     -14031.575      253.69538      253.69538      47815.438      47815.438      102.23437      102.23437    
Loop time of 346.901 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.249 ns/day, 96.361 hours/ns, 2.883 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    | 345.89     | 345.89     | 345.89     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15408    | 0.15408    | 0.15408    |   0.0 |  0.04
Output  | 0.00018927 | 0.00018927 | 0.00018927 |   0.0 |  0.00
Modify  | 0.75632    | 0.75632    | 0.75632    |   0.0 |  0.22
Other   |            | 0.0998     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446406 ave      446406 max      446406 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446406
Ave neighs/atom = 111.6015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.35865827841, Press = 0.0118800677065635
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.988 | 4.988 | 4.988 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    149000  -13900.437     -13900.437     -14031.575     -14031.575      253.69538      253.69538      47815.438      47815.438      102.23437      102.23437    
    150000  -13896.366     -13896.366     -14027.675     -14027.675      254.02677      254.02677      47808.899      47808.899      706.91213      706.91213    
Loop time of 345.435 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.250 ns/day, 95.954 hours/ns, 2.895 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 344.42     | 344.42     | 344.42     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15277    | 0.15277    | 0.15277    |   0.0 |  0.04
Output  | 0.00018984 | 0.00018984 | 0.00018984 |   0.0 |  0.00
Modify  | 0.76285    | 0.76285    | 0.76285    |   0.0 |  0.22
Other   |            | 0.1004     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       446460 ave      446460 max      446460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 446460
Ave neighs/atom = 111.615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
47826.8602025326

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0