# 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.5213917568326*${_u_distance}
variable latticeconst_converted equal 3.5213917568326*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.5213917568326
Lattice spacing in x,y,z = 3.5213918 3.5213918 3.5213918
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (35.213918 35.213918 35.213918)
  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 (35.213918 35.213918 35.213918)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Ni

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

kim interactions Ni
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KavousiNovakBaskes_2019_NiTi__MO_050461957184_002
pair_coeff * * Ni
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 58.6934

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43665.9617288553 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_050461957184_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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  -17669.144     -17669.144     -17800         -17800          253.15         253.15         43665.962      43665.962      3200.8602      3200.8602    
      1000  -17529.326     -17529.326     -17671.559     -17671.559      275.16071      275.16071      44143.366      44143.366     -3375.1326     -3375.1326    
Loop time of 58.1621 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.486 ns/day, 16.156 hours/ns, 17.193 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 58.008     | 58.008     | 58.008     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022153   | 0.022153   | 0.022153   |   0.0 |  0.04
Output  | 0.00016803 | 0.00016803 | 0.00016803 |   0.0 |  0.00
Modify  | 0.12062    | 0.12062    | 0.12062    |   0.0 |  0.21
Other   |            | 0.01101    |            |       |  0.02

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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -17529.326     -17529.326     -17671.559     -17671.559      275.16071      275.16071      44143.366      44143.366     -3375.1326     -3375.1326    
      2000  -17538.112     -17538.112     -17666.396     -17666.396      248.17417      248.17417      44040.643      44040.643      1059.6392      1059.6392    
Loop time of 74.6499 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.157 ns/day, 20.736 hours/ns, 13.396 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.497     | 74.497     | 74.497     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022866   | 0.022866   | 0.022866   |   0.0 |  0.03
Output  | 0.00010893 | 0.00010893 | 0.00010893 |   0.0 |  0.00
Modify  | 0.11875    | 0.11875    | 0.11875    |   0.0 |  0.16
Other   |            | 0.01123    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6109 ave        6109 max        6109 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540836 ave      540836 max      540836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540836
Ave neighs/atom = 135.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 = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -17538.112     -17538.112     -17666.396     -17666.396      248.17417      248.17417      44040.643      44040.643      1059.6392      1059.6392    
      3000  -17536.904     -17536.904     -17667.247     -17667.247      252.1575       252.1575       44082.109      44082.109     -559.27508     -559.27508    
Loop time of 74.6586 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.157 ns/day, 20.739 hours/ns, 13.394 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.505     | 74.505     | 74.505     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02308    | 0.02308    | 0.02308    |   0.0 |  0.03
Output  | 9.7283e-05 | 9.7283e-05 | 9.7283e-05 |   0.0 |  0.00
Modify  | 0.11875    | 0.11875    | 0.11875    |   0.0 |  0.16
Other   |            | 0.01128    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6135 ave        6135 max        6135 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541196 ave      541196 max      541196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 1.156 ns/day, 20.770 hours/ns, 13.374 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.62      | 74.62      | 74.62      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022858   | 0.022858   | 0.022858   |   0.0 |  0.03
Output  | 9.5289e-05 | 9.5289e-05 | 9.5289e-05 |   0.0 |  0.00
Modify  | 0.11877    | 0.11877    | 0.11877    |   0.0 |  0.16
Other   |            | 0.01128    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6119 ave        6119 max        6119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541092 ave      541092 max      541092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 1.157 ns/day, 20.750 hours/ns, 13.387 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.547     | 74.547     | 74.547     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023125   | 0.023125   | 0.023125   |   0.0 |  0.03
Output  | 6.5342e-05 | 6.5342e-05 | 6.5342e-05 |   0.0 |  0.00
Modify  | 0.11925    | 0.11925    | 0.11925    |   0.0 |  0.16
Other   |            | 0.01131    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6147 ave        6147 max        6147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541300 ave      541300 max      541300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541300
Ave neighs/atom = 135.325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.827124598999, Press = -540.260975238479
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -17539.097     -17539.097     -17669.956     -17669.956      253.15465      253.15465      44041.325      44041.325      863.77981      863.77981    
      6000  -17534.633     -17534.633     -17665.688     -17665.688      253.534        253.534        44116.044      44116.044     -1785.6655     -1785.6655    
Loop time of 74.6425 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.158 ns/day, 20.734 hours/ns, 13.397 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.485     | 74.485     | 74.485     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022946   | 0.022946   | 0.022946   |   0.0 |  0.03
Output  | 7.4099e-05 | 7.4099e-05 | 7.4099e-05 |   0.0 |  0.00
Modify  | 0.12289    | 0.12289    | 0.12289    |   0.0 |  0.16
Other   |            | 0.01132    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6124 ave        6124 max        6124 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541434 ave      541434 max      541434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541434
Ave neighs/atom = 135.3585
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.95448508074, Press = -25.255258182687
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -17534.633     -17534.633     -17665.688     -17665.688      253.534        253.534        44116.044      44116.044     -1785.6655     -1785.6655    
      7000  -17539.627     -17539.627     -17666.307     -17666.307      245.07111      245.07111      44017.68       44017.68       2013.9296      2013.9296    
Loop time of 74.7757 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.155 ns/day, 20.771 hours/ns, 13.373 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.619     | 74.619     | 74.619     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023105   | 0.023105   | 0.023105   |   0.0 |  0.03
Output  | 6.3078e-05 | 6.3078e-05 | 6.3078e-05 |   0.0 |  0.00
Modify  | 0.12262    | 0.12262    | 0.12262    |   0.0 |  0.16
Other   |            | 0.01127    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6168 ave        6168 max        6168 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540950 ave      540950 max      540950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540950
Ave neighs/atom = 135.2375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.100219562025, Press = -14.3843397950719
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -17539.627     -17539.627     -17666.307     -17666.307      245.07111      245.07111      44017.68       44017.68       2013.9296      2013.9296    
      8000  -17537.266     -17537.266     -17667.231     -17667.231      251.42484      251.42484      44103.076      44103.076     -1408.258      -1408.258     
Loop time of 74.7054 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.157 ns/day, 20.752 hours/ns, 13.386 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.549     | 74.549     | 74.549     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022953   | 0.022953   | 0.022953   |   0.0 |  0.03
Output  | 6.6094e-05 | 6.6094e-05 | 6.6094e-05 |   0.0 |  0.00
Modify  | 0.12258    | 0.12258    | 0.12258    |   0.0 |  0.16
Other   |            | 0.01121    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6142 ave        6142 max        6142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541400 ave      541400 max      541400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541400
Ave neighs/atom = 135.35
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.980290623659, Press = -22.950711242705
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -17537.266     -17537.266     -17667.231     -17667.231      251.42484      251.42484      44103.076      44103.076     -1408.258      -1408.258     
      9000  -17536.676     -17536.676     -17668.425     -17668.425      254.87662      254.87662      44054.745      44054.745      585.58479      585.58479    
Loop time of 74.552 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.709 hours/ns, 13.413 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.395     | 74.395     | 74.395     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02314    | 0.02314    | 0.02314    |   0.0 |  0.03
Output  | 7.0442e-05 | 7.0442e-05 | 7.0442e-05 |   0.0 |  0.00
Modify  | 0.12263    | 0.12263    | 0.12263    |   0.0 |  0.16
Other   |            | 0.01134    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6175 ave        6175 max        6175 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541012 ave      541012 max      541012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541012
Ave neighs/atom = 135.253
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.952233813276, Press = -3.87919731669759
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -17536.676     -17536.676     -17668.425     -17668.425      254.87662      254.87662      44054.745      44054.745      585.58479      585.58479    
     10000  -17537.626     -17537.626     -17668.608     -17668.608      253.39362      253.39362      44078.87       44078.87      -558.91261     -558.91261    
Loop time of 74.7631 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.156 ns/day, 20.768 hours/ns, 13.376 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.606     | 74.606     | 74.606     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022872   | 0.022872   | 0.022872   |   0.0 |  0.03
Output  | 7.0422e-05 | 7.0422e-05 | 7.0422e-05 |   0.0 |  0.00
Modify  | 0.12283    | 0.12283    | 0.12283    |   0.0 |  0.16
Other   |            | 0.01129    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6121 ave        6121 max        6121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541102 ave      541102 max      541102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541102
Ave neighs/atom = 135.2755
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.954954341326, Press = -12.2614020938522
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.373 | 5.373 | 5.373 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -17537.626     -17537.626     -17668.608     -17668.608      253.39362      253.39362      44078.87       44078.87      -558.91261     -558.91261    
     11000  -17540.242     -17540.242     -17670.126     -17670.126      251.26936      251.26936      44076.205      44076.205     -607.38348     -607.38348    
Loop time of 74.4718 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.687 hours/ns, 13.428 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.314     | 74.314     | 74.314     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023232   | 0.023232   | 0.023232   |   0.0 |  0.03
Output  | 6.2979e-05 | 6.2979e-05 | 6.2979e-05 |   0.0 |  0.00
Modify  | 0.12282    | 0.12282    | 0.12282    |   0.0 |  0.16
Other   |            | 0.0113     |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6232 ave        6232 max        6232 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541060 ave      541060 max      541060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541060
Ave neighs/atom = 135.265
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.926103231778, Press = 1.9994308683666
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -17540.242     -17540.242     -17670.126     -17670.126      251.26936      251.26936      44076.205      44076.205     -607.38348     -607.38348    
     12000  -17536.648     -17536.648     -17668.386     -17668.386      254.85747      254.85747      44017.421      44017.421      2039.1992      2039.1992    
Loop time of 74.5102 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.697 hours/ns, 13.421 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.354     | 74.354     | 74.354     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022606   | 0.022606   | 0.022606   |   0.0 |  0.03
Output  | 6.1506e-05 | 6.1506e-05 | 6.1506e-05 |   0.0 |  0.00
Modify  | 0.12278    | 0.12278    | 0.12278    |   0.0 |  0.16
Other   |            | 0.01112    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6055 ave        6055 max        6055 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540914 ave      540914 max      540914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540914
Ave neighs/atom = 135.2285
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.90440892741, Press = -11.9529192099407
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -17536.648     -17536.648     -17668.386     -17668.386      254.85747      254.85747      44017.421      44017.421      2039.1992      2039.1992    
     13000  -17538.148     -17538.148     -17670.592     -17670.592      256.22169      256.22169      44101.952      44101.952     -1726.1112     -1726.1112    
Loop time of 74.7762 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.155 ns/day, 20.771 hours/ns, 13.373 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.619     | 74.619     | 74.619     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023075   | 0.023075   | 0.023075   |   0.0 |  0.03
Output  | 6.5242e-05 | 6.5242e-05 | 6.5242e-05 |   0.0 |  0.00
Modify  | 0.12265    | 0.12265    | 0.12265    |   0.0 |  0.16
Other   |            | 0.01134    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6171 ave        6171 max        6171 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541358 ave      541358 max      541358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541358
Ave neighs/atom = 135.3395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.741513033644, Press = -2.27680953537369
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -17538.148     -17538.148     -17670.592     -17670.592      256.22169      256.22169      44101.952      44101.952     -1726.1112     -1726.1112    
     14000  -17535.729     -17535.729     -17668.352     -17668.352      256.56822      256.56822      44045.953      44045.953      831.17095      831.17095    
Loop time of 74.7397 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.156 ns/day, 20.761 hours/ns, 13.380 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.583     | 74.583     | 74.583     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022855   | 0.022855   | 0.022855   |   0.0 |  0.03
Output  | 0.0001435  | 0.0001435  | 0.0001435  |   0.0 |  0.00
Modify  | 0.12275    | 0.12275    | 0.12275    |   0.0 |  0.16
Other   |            | 0.01113    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6105 ave        6105 max        6105 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540886 ave      540886 max      540886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540886
Ave neighs/atom = 135.2215
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.695616368644, Press = -4.47660364634274
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -17535.729     -17535.729     -17668.352     -17668.352      256.56822      256.56822      44045.953      44045.953      831.17095      831.17095    
     15000  -17544.186     -17544.186     -17672.029     -17672.029      247.32201      247.32201      44081.518      44081.518     -1114.3245     -1114.3245    
Loop time of 74.8831 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.154 ns/day, 20.801 hours/ns, 13.354 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.726     | 74.726     | 74.726     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023229   | 0.023229   | 0.023229   |   0.0 |  0.03
Output  | 6.1957e-05 | 6.1957e-05 | 6.1957e-05 |   0.0 |  0.00
Modify  | 0.12281    | 0.12281    | 0.12281    |   0.0 |  0.16
Other   |            | 0.01129    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6198 ave        6198 max        6198 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541156 ave      541156 max      541156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541156
Ave neighs/atom = 135.289
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.630505442523, Press = -4.31847168098292
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -17544.186     -17544.186     -17672.029     -17672.029      247.32201      247.32201      44081.518      44081.518     -1114.3245     -1114.3245    
     16000  -17535.681     -17535.681     -17667.497     -17667.497      255.00775      255.00775      44053.684      44053.684      573.32252      573.32252    
Loop time of 74.6522 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.157 ns/day, 20.737 hours/ns, 13.395 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.495     | 74.495     | 74.495     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023182   | 0.023182   | 0.023182   |   0.0 |  0.03
Output  | 6.388e-05  | 6.388e-05  | 6.388e-05  |   0.0 |  0.00
Modify  | 0.12265    | 0.12265    | 0.12265    |   0.0 |  0.16
Other   |            | 0.01127    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6166 ave        6166 max        6166 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540990 ave      540990 max      540990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540990
Ave neighs/atom = 135.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 = 252.604916985286, Press = -1.3305799865702
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.373 | 5.373 | 5.373 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -17535.681     -17535.681     -17667.497     -17667.497      255.00775      255.00775      44053.684      44053.684      573.32252      573.32252    
     17000  -17541.409     -17541.409     -17671.587     -17671.587      251.83903      251.83903      44066.663      44066.663     -362.46221     -362.46221    
Loop time of 74.8424 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.154 ns/day, 20.790 hours/ns, 13.361 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.685     | 74.685     | 74.685     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023171   | 0.023171   | 0.023171   |   0.0 |  0.03
Output  | 6.6574e-05 | 6.6574e-05 | 6.6574e-05 |   0.0 |  0.00
Modify  | 0.12278    | 0.12278    | 0.12278    |   0.0 |  0.16
Other   |            | 0.01128    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6213 ave        6213 max        6213 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541174 ave      541174 max      541174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541174
Ave neighs/atom = 135.2935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.573079705047, Press = -6.25916528978935
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -17541.409     -17541.409     -17671.587     -17671.587      251.83903      251.83903      44066.663      44066.663     -362.46221     -362.46221    
     18000  -17536.942     -17536.942     -17666.745     -17666.745      251.11099      251.11099      44073.522      44073.522     -124.24852     -124.24852    
Loop time of 74.6132 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.158 ns/day, 20.726 hours/ns, 13.402 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.456     | 74.456     | 74.456     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022978   | 0.022978   | 0.022978   |   0.0 |  0.03
Output  | 7.1094e-05 | 7.1094e-05 | 7.1094e-05 |   0.0 |  0.00
Modify  | 0.12282    | 0.12282    | 0.12282    |   0.0 |  0.16
Other   |            | 0.01138    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6153 ave        6153 max        6153 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541046 ave      541046 max      541046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541046
Ave neighs/atom = 135.2615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.639359454497, Press = 0.979059938616198
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -17536.942     -17536.942     -17666.745     -17666.745      251.11099      251.11099      44073.522      44073.522     -124.24852     -124.24852    
     19000  -17537.458     -17537.458     -17668.062     -17668.062      252.66201      252.66201      44040.631      44040.631      1099.8341      1099.8341    
Loop time of 74.8176 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.155 ns/day, 20.783 hours/ns, 13.366 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.66      | 74.66      | 74.66      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0232     | 0.0232     | 0.0232     |   0.0 |  0.03
Output  | 6.1445e-05 | 6.1445e-05 | 6.1445e-05 |   0.0 |  0.00
Modify  | 0.12276    | 0.12276    | 0.12276    |   0.0 |  0.16
Other   |            | 0.01142    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6171 ave        6171 max        6171 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541016 ave      541016 max      541016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541016
Ave neighs/atom = 135.254
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.615697332265, Press = -5.58546110221917
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.373 | 5.373 | 5.373 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -17537.458     -17537.458     -17668.062     -17668.062      252.66201      252.66201      44040.631      44040.631      1099.8341      1099.8341    
     20000  -17537.829     -17537.829     -17667.669     -17667.669      251.1843       251.1843       44105.731      44105.731     -1625.8774     -1625.8774    
Loop time of 74.8433 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.154 ns/day, 20.790 hours/ns, 13.361 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.686     | 74.686     | 74.686     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023207   | 0.023207   | 0.023207   |   0.0 |  0.03
Output  | 5.9452e-05 | 5.9452e-05 | 5.9452e-05 |   0.0 |  0.00
Modify  | 0.12272    | 0.12272    | 0.12272    |   0.0 |  0.16
Other   |            | 0.01136    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6226 ave        6226 max        6226 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541310 ave      541310 max      541310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541310
Ave neighs/atom = 135.3275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.589981041165, Press = -1.18569346977833
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.373 | 5.373 | 5.373 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -17537.829     -17537.829     -17667.669     -17667.669      251.1843       251.1843       44105.731      44105.731     -1625.8774     -1625.8774    
     21000  -17536.074     -17536.074     -17669.284     -17669.284      257.70506      257.70506      44036.234      44036.234      1176.8259      1176.8259    
Loop time of 74.516 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.699 hours/ns, 13.420 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.359     | 74.359     | 74.359     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02325    | 0.02325    | 0.02325    |   0.0 |  0.03
Output  | 6.9701e-05 | 6.9701e-05 | 6.9701e-05 |   0.0 |  0.00
Modify  | 0.12273    | 0.12273    | 0.12273    |   0.0 |  0.16
Other   |            | 0.01134    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6209 ave        6209 max        6209 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540954 ave      540954 max      540954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540954
Ave neighs/atom = 135.2385
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.624335672775, Press = -2.36782294183114
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.373 | 5.373 | 5.373 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -17536.074     -17536.074     -17669.284     -17669.284      257.70506      257.70506      44036.234      44036.234      1176.8259      1176.8259    
     22000  -17542.812     -17542.812     -17669.814     -17669.814      245.69325      245.69325      44086.899      44086.899     -1084.2098     -1084.2098    
Loop time of 74.7027 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.157 ns/day, 20.751 hours/ns, 13.386 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.545     | 74.545     | 74.545     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023219   | 0.023219   | 0.023219   |   0.0 |  0.03
Output  | 6.9961e-05 | 6.9961e-05 | 6.9961e-05 |   0.0 |  0.00
Modify  | 0.12261    | 0.12261    | 0.12261    |   0.0 |  0.16
Other   |            | 0.01135    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6218 ave        6218 max        6218 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541206 ave      541206 max      541206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541206
Ave neighs/atom = 135.3015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.64598428395, Press = -2.31356095567196
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -17542.812     -17542.812     -17669.814     -17669.814      245.69325      245.69325      44086.899      44086.899     -1084.2098     -1084.2098    
     23000  -17535.085     -17535.085     -17667.677     -17667.677      256.50819      256.50819      44021.526      44021.526      1962.095       1962.095     
Loop time of 74.6586 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.157 ns/day, 20.738 hours/ns, 13.394 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.501     | 74.501     | 74.501     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023019   | 0.023019   | 0.023019   |   0.0 |  0.03
Output  | 5.311e-05  | 5.311e-05  | 5.311e-05  |   0.0 |  0.00
Modify  | 0.12268    | 0.12268    | 0.12268    |   0.0 |  0.16
Other   |            | 0.01137    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6124 ave        6124 max        6124 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541018 ave      541018 max      541018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541018
Ave neighs/atom = 135.2545
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.612535081987, Press = -1.16799430658098
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.373 | 5.373 | 5.373 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -17535.085     -17535.085     -17667.677     -17667.677      256.50819      256.50819      44021.526      44021.526      1962.095       1962.095     
     24000  -17537.9       -17537.9       -17666.287     -17666.287      248.37229      248.37229      44120.358      44120.358     -2101.0297     -2101.0297    
Loop time of 74.4393 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.678 hours/ns, 13.434 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.282     | 74.282     | 74.282     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02314    | 0.02314    | 0.02314    |   0.0 |  0.03
Output  | 6.376e-05  | 6.376e-05  | 6.376e-05  |   0.0 |  0.00
Modify  | 0.12257    | 0.12257    | 0.12257    |   0.0 |  0.16
Other   |            | 0.01137    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6205 ave        6205 max        6205 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541346 ave      541346 max      541346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541346
Ave neighs/atom = 135.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 = 252.652377430581, Press = -4.60291286959174
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -17537.9       -17537.9       -17666.287     -17666.287      248.37229      248.37229      44120.358      44120.358     -2101.0297     -2101.0297    
     25000  -17537.029     -17537.029     -17666.581     -17666.581      250.62761      250.62761      44040.237      44040.237      1162.5304      1162.5304    
Loop time of 74.5491 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.708 hours/ns, 13.414 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.392     | 74.392     | 74.392     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023011   | 0.023011   | 0.023011   |   0.0 |  0.03
Output  | 6.3089e-05 | 6.3089e-05 | 6.3089e-05 |   0.0 |  0.00
Modify  | 0.12278    | 0.12278    | 0.12278    |   0.0 |  0.16
Other   |            | 0.01127    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6145 ave        6145 max        6145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540970 ave      540970 max      540970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540970
Ave neighs/atom = 135.2425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.658827002124, Press = 0.50351266210838
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -17537.029     -17537.029     -17666.581     -17666.581      250.62761      250.62761      44040.237      44040.237      1162.5304      1162.5304    
     26000  -17534.007     -17534.007     -17664.688     -17664.688      252.81189      252.81189      44063.994      44063.994      403.92248      403.92248    
Loop time of 74.5213 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.700 hours/ns, 13.419 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.364     | 74.364     | 74.364     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023115   | 0.023115   | 0.023115   |   0.0 |  0.03
Output  | 6.4121e-05 | 6.4121e-05 | 6.4121e-05 |   0.0 |  0.00
Modify  | 0.12274    | 0.12274    | 0.12274    |   0.0 |  0.16
Other   |            | 0.01138    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6189 ave        6189 max        6189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541314 ave      541314 max      541314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541314
Ave neighs/atom = 135.3285
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.693088757397, Press = -3.29692869478092
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -17534.007     -17534.007     -17664.688     -17664.688      252.81189      252.81189      44063.994      44063.994      403.92248      403.92248    
     27000  -17538.715     -17538.715     -17668.29      -17668.29       250.67198      250.67198      44084.571      44084.571     -772.71502     -772.71502    
Loop time of 74.6451 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.157 ns/day, 20.735 hours/ns, 13.397 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.488     | 74.488     | 74.488     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023089   | 0.023089   | 0.023089   |   0.0 |  0.03
Output  | 6.1455e-05 | 6.1455e-05 | 6.1455e-05 |   0.0 |  0.00
Modify  | 0.12256    | 0.12256    | 0.12256    |   0.0 |  0.16
Other   |            | 0.01131    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6187 ave        6187 max        6187 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541236 ave      541236 max      541236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541236
Ave neighs/atom = 135.309
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.725436969444, Press = -0.448012912754369
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -17538.715     -17538.715     -17668.29      -17668.29       250.67198      250.67198      44084.571      44084.571     -772.71502     -772.71502    
     28000  -17536.226     -17536.226     -17667         -17667          252.99156      252.99156      44040.515      44040.515      1259.112       1259.112     
Loop time of 74.4612 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.684 hours/ns, 13.430 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.304     | 74.304     | 74.304     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023172   | 0.023172   | 0.023172   |   0.0 |  0.03
Output  | 5.7258e-05 | 5.7258e-05 | 5.7258e-05 |   0.0 |  0.00
Modify  | 0.12263    | 0.12263    | 0.12263    |   0.0 |  0.16
Other   |            | 0.01142    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6191 ave        6191 max        6191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541024 ave      541024 max      541024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541024
Ave neighs/atom = 135.256
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.807921658952, Press = -1.65699752300173
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -17536.226     -17536.226     -17667         -17667          252.99156      252.99156      44040.515      44040.515      1259.112       1259.112     
     29000  -17536.941     -17536.941     -17666.922     -17666.922      251.45812      251.45812      44112.776      44112.776     -1807.4108     -1807.4108    
Loop time of 74.5802 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.158 ns/day, 20.717 hours/ns, 13.408 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.423     | 74.423     | 74.423     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023083   | 0.023083   | 0.023083   |   0.0 |  0.03
Output  | 5.907e-05  | 5.907e-05  | 5.907e-05  |   0.0 |  0.00
Modify  | 0.12258    | 0.12258    | 0.12258    |   0.0 |  0.16
Other   |            | 0.01128    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6139 ave        6139 max        6139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541312 ave      541312 max      541312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541312
Ave neighs/atom = 135.328
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.855269302175, Press = -1.75964431710803
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -17536.941     -17536.941     -17666.922     -17666.922      251.45812      251.45812      44112.776      44112.776     -1807.4108     -1807.4108    
     30000  -17541.146     -17541.146     -17669.648     -17669.648      248.596        248.596        43968.579      43968.579      3842.2825      3842.2825    
Loop time of 74.6006 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.158 ns/day, 20.722 hours/ns, 13.405 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.443     | 74.443     | 74.443     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023075   | 0.023075   | 0.023075   |   0.0 |  0.03
Output  | 6.5533e-05 | 6.5533e-05 | 6.5533e-05 |   0.0 |  0.00
Modify  | 0.12273    | 0.12273    | 0.12273    |   0.0 |  0.16
Other   |            | 0.01135    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6167 ave        6167 max        6167 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540946 ave      540946 max      540946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540946
Ave neighs/atom = 135.2365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.869616886593, Press = 1.04785904813192
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -17541.146     -17541.146     -17669.648     -17669.648      248.596        248.596        43968.579      43968.579      3842.2825      3842.2825    
     31000  -17535.734     -17535.734     -17663.804     -17663.804      247.76013      247.76013      44105.669      44105.669     -1204.9948     -1204.9948    
Loop time of 74.7172 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.156 ns/day, 20.755 hours/ns, 13.384 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.56      | 74.56      | 74.56      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023017   | 0.023017   | 0.023017   |   0.0 |  0.03
Output  | 6.2377e-05 | 6.2377e-05 | 6.2377e-05 |   0.0 |  0.00
Modify  | 0.12261    | 0.12261    | 0.12261    |   0.0 |  0.16
Other   |            | 0.01138    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6169 ave        6169 max        6169 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541638 ave      541638 max      541638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541638
Ave neighs/atom = 135.4095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.828446423812, Press = -2.7320906086548
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -17535.734     -17535.734     -17663.804     -17663.804      247.76013      247.76013      44105.669      44105.669     -1204.9948     -1204.9948    
     32000  -17542.717     -17542.717     -17671.705     -17671.705      249.53465      249.53465      44050.756      44050.756      226.0567       226.0567     
Loop time of 74.7009 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.157 ns/day, 20.750 hours/ns, 13.387 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.544     | 74.544     | 74.544     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023008   | 0.023008   | 0.023008   |   0.0 |  0.03
Output  | 5.9242e-05 | 5.9242e-05 | 5.9242e-05 |   0.0 |  0.00
Modify  | 0.12281    | 0.12281    | 0.12281    |   0.0 |  0.16
Other   |            | 0.01131    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6167 ave        6167 max        6167 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540992 ave      540992 max      540992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540992
Ave neighs/atom = 135.248
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.811293813979, Press = 0.381309531210959
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -17542.717     -17542.717     -17671.705     -17671.705      249.53465      249.53465      44050.756      44050.756      226.0567       226.0567     
     33000  -17537.288     -17537.288     -17668.999     -17668.999      254.80259      254.80259      44056.348      44056.348      380.44942      380.44942    
Loop time of 74.8151 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.155 ns/day, 20.782 hours/ns, 13.366 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.658     | 74.658     | 74.658     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023045   | 0.023045   | 0.023045   |   0.0 |  0.03
Output  | 5.4212e-05 | 5.4212e-05 | 5.4212e-05 |   0.0 |  0.00
Modify  | 0.12272    | 0.12272    | 0.12272    |   0.0 |  0.16
Other   |            | 0.01136    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6151 ave        6151 max        6151 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541142 ave      541142 max      541142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541142
Ave neighs/atom = 135.2855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.806212795984, Press = -2.22946642574961
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -17537.288     -17537.288     -17668.999     -17668.999      254.80259      254.80259      44056.348      44056.348      380.44942      380.44942    
     34000  -17532.272     -17532.272     -17666.956     -17666.956      260.55417      260.55417      44095.789      44095.789     -931.46476     -931.46476    
Loop time of 74.3975 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.161 ns/day, 20.666 hours/ns, 13.441 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.241     | 74.241     | 74.241     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023109   | 0.023109   | 0.023109   |   0.0 |  0.03
Output  | 5.9762e-05 | 5.9762e-05 | 5.9762e-05 |   0.0 |  0.00
Modify  | 0.12249    | 0.12249    | 0.12249    |   0.0 |  0.16
Other   |            | 0.01132    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6169 ave        6169 max        6169 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541184 ave      541184 max      541184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541184
Ave neighs/atom = 135.296
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.839396029015, Press = -0.642793984722739
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -17532.272     -17532.272     -17666.956     -17666.956      260.55417      260.55417      44095.789      44095.789     -931.46476     -931.46476    
     35000  -17538.292     -17538.292     -17667.49      -17667.49       249.94231      249.94231      44040.488      44040.488      1148.4734      1148.4734    
Loop time of 74.6189 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.158 ns/day, 20.727 hours/ns, 13.401 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.462     | 74.462     | 74.462     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023068   | 0.023068   | 0.023068   |   0.0 |  0.03
Output  | 6.7296e-05 | 6.7296e-05 | 6.7296e-05 |   0.0 |  0.00
Modify  | 0.12258    | 0.12258    | 0.12258    |   0.0 |  0.16
Other   |            | 0.01123    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6136 ave        6136 max        6136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540998 ave      540998 max      540998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540998
Ave neighs/atom = 135.2495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.868000977813, Press = -0.905954419507225
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -17538.292     -17538.292     -17667.49      -17667.49       249.94231      249.94231      44040.488      44040.488      1148.4734      1148.4734    
     36000  -17533.436     -17533.436     -17665.437     -17665.437      255.3652       255.3652       44082.345      44082.345     -342.56426     -342.56426    
Loop time of 74.6779 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.157 ns/day, 20.744 hours/ns, 13.391 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.521     | 74.521     | 74.521     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023121   | 0.023121   | 0.023121   |   0.0 |  0.03
Output  | 5.3901e-05 | 5.3901e-05 | 5.3901e-05 |   0.0 |  0.00
Modify  | 0.12261    | 0.12261    | 0.12261    |   0.0 |  0.16
Other   |            | 0.01139    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6167 ave        6167 max        6167 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541226 ave      541226 max      541226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541226
Ave neighs/atom = 135.3065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.916146101679, Press = -1.25465854570937
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -17533.436     -17533.436     -17665.437     -17665.437      255.3652       255.3652       44082.345      44082.345     -342.56426     -342.56426    
     37000  -17538.76      -17538.76      -17667.242     -17667.242      248.55562      248.55562      44064.996      44064.996      111.40658      111.40658    
Loop time of 74.6997 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.157 ns/day, 20.750 hours/ns, 13.387 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.543     | 74.543     | 74.543     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02307    | 0.02307    | 0.02307    |   0.0 |  0.03
Output  | 5.7097e-05 | 5.7097e-05 | 5.7097e-05 |   0.0 |  0.00
Modify  | 0.12256    | 0.12256    | 0.12256    |   0.0 |  0.16
Other   |            | 0.01137    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6139 ave        6139 max        6139 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540992 ave      540992 max      540992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540992
Ave neighs/atom = 135.248
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.962098724816, Press = -0.467155783914151
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -17538.76      -17538.76      -17667.242     -17667.242      248.55562      248.55562      44064.996      44064.996      111.40658      111.40658    
     38000  -17536.17      -17536.17      -17667.096     -17667.096      253.28565      253.28565      44049.948      44049.948      812.57571      812.57571    
Loop time of 74.5786 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.716 hours/ns, 13.409 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.421     | 74.421     | 74.421     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023098   | 0.023098   | 0.023098   |   0.0 |  0.03
Output  | 5.7829e-05 | 5.7829e-05 | 5.7829e-05 |   0.0 |  0.00
Modify  | 0.12259    | 0.12259    | 0.12259    |   0.0 |  0.16
Other   |            | 0.01132    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6172 ave        6172 max        6172 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541152 ave      541152 max      541152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541152
Ave neighs/atom = 135.288
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.998237954987, Press = -1.12830095519241
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -17536.17      -17536.17      -17667.096     -17667.096      253.28565      253.28565      44049.948      44049.948      812.57571      812.57571    
     39000  -17538.861     -17538.861     -17670.444     -17670.444      254.5568       254.5568       44116.517      44116.517     -2296.7594     -2296.7594    
Loop time of 74.4746 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.160 ns/day, 20.687 hours/ns, 13.427 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.317     | 74.317     | 74.317     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02295    | 0.02295    | 0.02295    |   0.0 |  0.03
Output  | 6.396e-05  | 6.396e-05  | 6.396e-05  |   0.0 |  0.00
Modify  | 0.12276    | 0.12276    | 0.12276    |   0.0 |  0.16
Other   |            | 0.01136    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6132 ave        6132 max        6132 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541250 ave      541250 max      541250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541250
Ave neighs/atom = 135.3125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.984762105124, Press = -1.56640425659755
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -17538.861     -17538.861     -17670.444     -17670.444      254.5568       254.5568       44116.517      44116.517     -2296.7594     -2296.7594    
     40000  -17539.391     -17539.391     -17669.385     -17669.385      251.4816       251.4816       44021.366      44021.366      1788.25        1788.25      
Loop time of 74.5361 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.704 hours/ns, 13.416 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.379     | 74.379     | 74.379     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023037   | 0.023037   | 0.023037   |   0.0 |  0.03
Output  | 5.3119e-05 | 5.3119e-05 | 5.3119e-05 |   0.0 |  0.00
Modify  | 0.12265    | 0.12265    | 0.12265    |   0.0 |  0.16
Other   |            | 0.01133    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6130 ave        6130 max        6130 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540768 ave      540768 max      540768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540768
Ave neighs/atom = 135.192
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.991378883351, Press = 0.342724031005793
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -17539.391     -17539.391     -17669.385     -17669.385      251.4816       251.4816       44021.366      44021.366      1788.25        1788.25      
     41000  -17536.385     -17536.385     -17668.226     -17668.226      255.05594      255.05594      44078.354      44078.354     -449.8553      -449.8553     
Loop time of 74.6063 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.158 ns/day, 20.724 hours/ns, 13.404 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.449     | 74.449     | 74.449     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02307    | 0.02307    | 0.02307    |   0.0 |  0.03
Output  | 5.6947e-05 | 5.6947e-05 | 5.6947e-05 |   0.0 |  0.00
Modify  | 0.12257    | 0.12257    | 0.12257    |   0.0 |  0.16
Other   |            | 0.01138    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6174 ave        6174 max        6174 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541240 ave      541240 max      541240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541240
Ave neighs/atom = 135.31
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.949456544708, Press = -2.25002901407786
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -17536.385     -17536.385     -17668.226     -17668.226      255.05594      255.05594      44078.354      44078.354     -449.8553      -449.8553     
     42000  -17540.442     -17540.442     -17670.515     -17670.515      251.63361      251.63361      44070.762      44070.762     -458.95038     -458.95038    
Loop time of 74.6155 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.158 ns/day, 20.727 hours/ns, 13.402 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.458     | 74.458     | 74.458     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023094   | 0.023094   | 0.023094   |   0.0 |  0.03
Output  | 7.0132e-05 | 7.0132e-05 | 7.0132e-05 |   0.0 |  0.00
Modify  | 0.12293    | 0.12293    | 0.12293    |   0.0 |  0.16
Other   |            | 0.01142    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6182 ave        6182 max        6182 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541084 ave      541084 max      541084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541084
Ave neighs/atom = 135.271
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.935149315241, Press = -0.167364095612617
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -17540.442     -17540.442     -17670.515     -17670.515      251.63361      251.63361      44070.762      44070.762     -458.95038     -458.95038    
     43000  -17537.237     -17537.237     -17667.694     -17667.694      252.37932      252.37932      44055.573      44055.573      507.90761      507.90761    
Loop time of 74.5764 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.716 hours/ns, 13.409 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.419     | 74.419     | 74.419     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023156   | 0.023156   | 0.023156   |   0.0 |  0.03
Output  | 6.5924e-05 | 6.5924e-05 | 6.5924e-05 |   0.0 |  0.00
Modify  | 0.12289    | 0.12289    | 0.12289    |   0.0 |  0.16
Other   |            | 0.01148    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6178 ave        6178 max        6178 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541054 ave      541054 max      541054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541054
Ave neighs/atom = 135.2635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.96807776086, Press = -1.32091637694758
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -17537.237     -17537.237     -17667.694     -17667.694      252.37932      252.37932      44055.573      44055.573      507.90761      507.90761    
     44000  -17536.738     -17536.738     -17669.295     -17669.295      256.44018      256.44018      44075.605      44075.605     -514.70001     -514.70001    
Loop time of 74.696 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.157 ns/day, 20.749 hours/ns, 13.388 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.539     | 74.539     | 74.539     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023168   | 0.023168   | 0.023168   |   0.0 |  0.03
Output  | 5.5885e-05 | 5.5885e-05 | 5.5885e-05 |   0.0 |  0.00
Modify  | 0.12257    | 0.12257    | 0.12257    |   0.0 |  0.16
Other   |            | 0.01128    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6154 ave        6154 max        6154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541390 ave      541390 max      541390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541390
Ave neighs/atom = 135.3475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.96448559403, Press = -0.885965186945482
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -17536.738     -17536.738     -17669.295     -17669.295      256.44018      256.44018      44075.605      44075.605     -514.70001     -514.70001    
     45000  -17539.872     -17539.872     -17670.046     -17670.046      251.83159      251.83159      44060.181      44060.181      74.943277      74.943277    
Loop time of 74.5883 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.158 ns/day, 20.719 hours/ns, 13.407 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.431     | 74.431     | 74.431     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023359   | 0.023359   | 0.023359   |   0.0 |  0.03
Output  | 0.0001361  | 0.0001361  | 0.0001361  |   0.0 |  0.00
Modify  | 0.12265    | 0.12265    | 0.12265    |   0.0 |  0.16
Other   |            | 0.01139    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6186 ave        6186 max        6186 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541204 ave      541204 max      541204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541204
Ave neighs/atom = 135.301
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.949750689023, Press = -0.91140025807432
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -17539.872     -17539.872     -17670.046     -17670.046      251.83159      251.83159      44060.181      44060.181      74.943277      74.943277    
     46000  -17532.802     -17532.802     -17665.733     -17665.733      257.16368      257.16368      44080.656      44080.656     -282.34556     -282.34556    
Loop time of 74.5586 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.711 hours/ns, 13.412 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.401     | 74.401     | 74.401     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023049   | 0.023049   | 0.023049   |   0.0 |  0.03
Output  | 6.3008e-05 | 6.3008e-05 | 6.3008e-05 |   0.0 |  0.00
Modify  | 0.12263    | 0.12263    | 0.12263    |   0.0 |  0.16
Other   |            | 0.01139    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6176 ave        6176 max        6176 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541142 ave      541142 max      541142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541142
Ave neighs/atom = 135.2855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.975788555851, Press = -0.570552746266138
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -17532.802     -17532.802     -17665.733     -17665.733      257.16368      257.16368      44080.656      44080.656     -282.34556     -282.34556    
     47000  -17538.092     -17538.092     -17669.996     -17669.996      255.17678      255.17678      44056.159      44056.159      237.07432      237.07432    
Loop time of 74.5426 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.706 hours/ns, 13.415 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.385     | 74.385     | 74.385     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023091   | 0.023091   | 0.023091   |   0.0 |  0.03
Output  | 7.0432e-05 | 7.0432e-05 | 7.0432e-05 |   0.0 |  0.00
Modify  | 0.1227     | 0.1227     | 0.1227     |   0.0 |  0.16
Other   |            | 0.01143    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6151 ave        6151 max        6151 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541268 ave      541268 max      541268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541268
Ave neighs/atom = 135.317
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.993176084635, Press = -1.49674797753401
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -17538.092     -17538.092     -17669.996     -17669.996      255.17678      255.17678      44056.159      44056.159      237.07432      237.07432    
     48000  -17535.157     -17535.157     -17667.006     -17667.006      255.0717       255.0717       44107.831      44107.831     -1635.3443     -1635.3443    
Loop time of 74.5819 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.158 ns/day, 20.717 hours/ns, 13.408 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.424     | 74.424     | 74.424     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023231   | 0.023231   | 0.023231   |   0.0 |  0.03
Output  | 5.5444e-05 | 5.5444e-05 | 5.5444e-05 |   0.0 |  0.00
Modify  | 0.12278    | 0.12278    | 0.12278    |   0.0 |  0.16
Other   |            | 0.01137    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6198 ave        6198 max        6198 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541174 ave      541174 max      541174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0