# 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.5213917419314393*${_u_distance}
variable latticeconst_converted equal 3.5213917419314393*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52139174193144
Lattice spacing in x,y,z = 3.5213917 3.5213917 3.5213917
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (35.213917 35.213917 35.213917)
  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.213917 35.213917 35.213917)
  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_MaiselKoZhang_2017_VNiTi__MO_744610363128_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.9611745232    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9611745232/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9611745232/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9611745232/(1*1*${_u_distance})
variable      V0_metal equal 43665.9611745232/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 43665.9611745232*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43665.9611745232 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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.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_744610363128_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  -17658.806     -17658.806     -17800         -17800          273.15         273.15         43665.961      43665.961      3453.7683      3453.7683    
      1000  -17508.879     -17508.879     -17649.246     -17649.246      271.55122      271.55122      44136.4        44136.4       -1137.0155     -1137.0155    
Loop time of 58.6502 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.473 ns/day, 16.292 hours/ns, 17.050 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.498     | 58.498     | 58.498     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02177    | 0.02177    | 0.02177    |   0.0 |  0.04
Output  | 0.00018051 | 0.00018051 | 0.00018051 |   0.0 |  0.00
Modify  | 0.11888    | 0.11888    | 0.11888    |   0.0 |  0.20
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  -17508.879     -17508.879     -17649.246     -17649.246      271.55122      271.55122      44136.4        44136.4       -1137.0155     -1137.0155    
      2000  -17516.944     -17516.944     -17659.373     -17659.373      275.53686      275.53686      44096.34       44096.34      -382.76575     -382.76575    
Loop time of 75.7758 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.140 ns/day, 21.049 hours/ns, 13.197 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    | 75.623     | 75.623     | 75.623     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022623   | 0.022623   | 0.022623   |   0.0 |  0.03
Output  | 8.6001e-05 | 8.6001e-05 | 8.6001e-05 |   0.0 |  0.00
Modify  | 0.11869    | 0.11869    | 0.11869    |   0.0 |  0.16
Other   |            | 0.01094    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6128 ave        6128 max        6128 min
Histogram: 1 0 0 0 0 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 = 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  -17516.944     -17516.944     -17659.373     -17659.373      275.53686      275.53686      44096.34       44096.34      -382.76575     -382.76575    
      3000  -17516.423     -17516.423     -17658.607     -17658.607      275.06361      275.06361      44062.89       44062.89       1073.0556      1073.0556    
Loop time of 75.7557 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.043 hours/ns, 13.200 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    | 75.603     | 75.603     | 75.603     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022566   | 0.022566   | 0.022566   |   0.0 |  0.03
Output  | 8.3297e-05 | 8.3297e-05 | 8.3297e-05 |   0.0 |  0.00
Modify  | 0.1187     | 0.1187     | 0.1187     |   0.0 |  0.16
Other   |            | 0.01087    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6129 ave        6129 max        6129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540890 ave      540890 max      540890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540890
Ave neighs/atom = 135.2225
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -17516.423     -17516.423     -17658.607     -17658.607      275.06361      275.06361      44062.89       44062.89       1073.0556      1073.0556    
      4000  -17514.132     -17514.132     -17656.543     -17656.543      275.5049       275.5049       44117.146      44117.146     -981.27934     -981.27934    
Loop time of 75.7423 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.040 hours/ns, 13.203 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    | 75.59      | 75.59      | 75.59      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022556   | 0.022556   | 0.022556   |   0.0 |  0.03
Output  | 7.1825e-05 | 7.1825e-05 | 7.1825e-05 |   0.0 |  0.00
Modify  | 0.11869    | 0.11869    | 0.11869    |   0.0 |  0.16
Other   |            | 0.01086    |            |       |  0.01

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:       541096 ave      541096 max      541096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541096
Ave neighs/atom = 135.274
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -17514.132     -17514.132     -17656.543     -17656.543      275.5049       275.5049       44117.146      44117.146     -981.27934     -981.27934    
      5000  -17518.809     -17518.809     -17660.899     -17660.899      274.88132      274.88132      44088.433      44088.433     -267.16671     -267.16671    
Loop time of 75.5591 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.143 ns/day, 20.989 hours/ns, 13.235 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    | 75.406     | 75.406     | 75.406     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022646   | 0.022646   | 0.022646   |   0.0 |  0.03
Output  | 6.0203e-05 | 6.0203e-05 | 6.0203e-05 |   0.0 |  0.00
Modify  | 0.11904    | 0.11904    | 0.11904    |   0.0 |  0.16
Other   |            | 0.01087    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6133 ave        6133 max        6133 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540978 ave      540978 max      540978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540978
Ave neighs/atom = 135.2445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.531691748689, Press = -380.749484261325
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17518.809     -17518.809     -17660.899     -17660.899      274.88132      274.88132      44088.433      44088.433     -267.16671     -267.16671    
      6000  -17513.33      -17513.33      -17655.541     -17655.541      275.11658      275.11658      44054.637      44054.637      1660.6306      1660.6306    
Loop time of 75.5713 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.143 ns/day, 20.992 hours/ns, 13.233 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    | 75.415     | 75.415     | 75.415     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022578   | 0.022578   | 0.022578   |   0.0 |  0.03
Output  | 5.835e-05  | 5.835e-05  | 5.835e-05  |   0.0 |  0.00
Modify  | 0.12243    | 0.12243    | 0.12243    |   0.0 |  0.16
Other   |            | 0.01087    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6138 ave        6138 max        6138 min
Histogram: 1 0 0 0 0 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 = 272.780834036118, Press = 6.00906594731061
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17513.33      -17513.33      -17655.541     -17655.541      275.11658      275.11658      44054.637      44054.637      1660.6306      1660.6306    
      7000  -17519.045     -17519.045     -17661.592     -17661.592      275.76701      275.76701      44131.034      44131.034     -2019.6401     -2019.6401    
Loop time of 75.7095 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.030 hours/ns, 13.208 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    | 75.553     | 75.553     | 75.553     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022874   | 0.022874   | 0.022874   |   0.0 |  0.03
Output  | 5.5234e-05 | 5.5234e-05 | 5.5234e-05 |   0.0 |  0.00
Modify  | 0.1228     | 0.1228     | 0.1228     |   0.0 |  0.16
Other   |            | 0.0108     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6196 ave        6196 max        6196 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541168 ave      541168 max      541168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541168
Ave neighs/atom = 135.292
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.050120195285, Press = 11.1554972453862
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17519.045     -17519.045     -17661.592     -17661.592      275.76701      275.76701      44131.034      44131.034     -2019.6401     -2019.6401    
      8000  -17515.287     -17515.287     -17658.406     -17658.406      276.8726       276.8726       44116.322      44116.322     -1125.7174     -1125.7174    
Loop time of 75.5284 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.144 ns/day, 20.980 hours/ns, 13.240 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    | 75.372     | 75.372     | 75.372     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022599   | 0.022599   | 0.022599   |   0.0 |  0.03
Output  | 6.0855e-05 | 6.0855e-05 | 6.0855e-05 |   0.0 |  0.00
Modify  | 0.12272    | 0.12272    | 0.12272    |   0.0 |  0.16
Other   |            | 0.01092    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6082 ave        6082 max        6082 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540820 ave      540820 max      540820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540820
Ave neighs/atom = 135.205
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.944066528073, Press = -24.5879654225889
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17515.287     -17515.287     -17658.406     -17658.406      276.8726       276.8726       44116.322      44116.322     -1125.7174     -1125.7174    
      9000  -17520.423     -17520.423     -17658.187     -17658.187      266.51326      266.51326      44048.808      44048.808      1610.2561      1610.2561    
Loop time of 75.7289 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.036 hours/ns, 13.205 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    | 75.573     | 75.573     | 75.573     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022522   | 0.022522   | 0.022522   |   0.0 |  0.03
Output  | 5.7087e-05 | 5.7087e-05 | 5.7087e-05 |   0.0 |  0.00
Modify  | 0.12242    | 0.12242    | 0.12242    |   0.0 |  0.16
Other   |            | 0.01088    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6141 ave        6141 max        6141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540774 ave      540774 max      540774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540774
Ave neighs/atom = 135.1935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.589204529261, Press = -2.67058101523245
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17520.423     -17520.423     -17658.187     -17658.187      266.51326      266.51326      44048.808      44048.808      1610.2561      1610.2561    
     10000  -17514.543     -17514.543     -17655.998     -17655.998      273.65482      273.65482      44103.1        44103.1       -307.29819     -307.29819    
Loop time of 75.5966 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.143 ns/day, 20.999 hours/ns, 13.228 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    | 75.441     | 75.441     | 75.441     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022472   | 0.022472   | 0.022472   |   0.0 |  0.03
Output  | 6.3449e-05 | 6.3449e-05 | 6.3449e-05 |   0.0 |  0.00
Modify  | 0.1226     | 0.1226     | 0.1226     |   0.0 |  0.16
Other   |            | 0.01088    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6077 ave        6077 max        6077 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541154 ave      541154 max      541154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541154
Ave neighs/atom = 135.2885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.584455184201, Press = 0.719659131747266
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     10000  -17514.543     -17514.543     -17655.998     -17655.998      273.65482      273.65482      44103.1        44103.1       -307.29819     -307.29819    
     11000  -17518.762     -17518.762     -17660.667     -17660.667      274.52536      274.52536      44105.959      44105.959     -931.33242     -931.33242    
Loop time of 75.7893 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.140 ns/day, 21.053 hours/ns, 13.194 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    | 75.633     | 75.633     | 75.633     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02269    | 0.02269    | 0.02269    |   0.0 |  0.03
Output  | 5.8009e-05 | 5.8009e-05 | 5.8009e-05 |   0.0 |  0.00
Modify  | 0.12273    | 0.12273    | 0.12273    |   0.0 |  0.16
Other   |            | 0.01081    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6192 ave        6192 max        6192 min
Histogram: 1 0 0 0 0 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 = 272.471702759803, Press = -4.25745943129757
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     11000  -17518.762     -17518.762     -17660.667     -17660.667      274.52536      274.52536      44105.959      44105.959     -931.33242     -931.33242    
     12000  -17516.919     -17516.919     -17657.484     -17657.484      271.93198      271.93198      44062.876      44062.876      1230.6524      1230.6524    
Loop time of 75.608 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.143 ns/day, 21.002 hours/ns, 13.226 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    | 75.452     | 75.452     | 75.452     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02243    | 0.02243    | 0.02243    |   0.0 |  0.03
Output  | 6.9371e-05 | 6.9371e-05 | 6.9371e-05 |   0.0 |  0.00
Modify  | 0.12259    | 0.12259    | 0.12259    |   0.0 |  0.16
Other   |            | 0.01087    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6095 ave        6095 max        6095 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540986 ave      540986 max      540986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540986
Ave neighs/atom = 135.2465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.699129111547, Press = -2.24728120270558
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17516.919     -17516.919     -17657.484     -17657.484      271.93198      271.93198      44062.876      44062.876      1230.6524      1230.6524    
     13000  -17516.37      -17516.37      -17654.887     -17654.887      267.97047      267.97047      44090.955      44090.955      286.03764      286.03764    
Loop time of 75.6134 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.143 ns/day, 21.004 hours/ns, 13.225 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    | 75.457     | 75.457     | 75.457     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022542   | 0.022542   | 0.022542   |   0.0 |  0.03
Output  | 7.0272e-05 | 7.0272e-05 | 7.0272e-05 |   0.0 |  0.00
Modify  | 0.1226     | 0.1226     | 0.1226     |   0.0 |  0.16
Other   |            | 0.01097    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6156 ave        6156 max        6156 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541134 ave      541134 max      541134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541134
Ave neighs/atom = 135.2835
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.866281257178, Press = 3.4589786669636
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17516.37      -17516.37      -17654.887     -17654.887      267.97047      267.97047      44090.955      44090.955      286.03764      286.03764    
     14000  -17521.597     -17521.597     -17660.261     -17660.261      268.25535      268.25535      44112.123      44112.123     -1241.1396     -1241.1396    
Loop time of 75.6761 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.142 ns/day, 21.021 hours/ns, 13.214 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    | 75.52      | 75.52      | 75.52      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022556   | 0.022556   | 0.022556   |   0.0 |  0.03
Output  | 5.4252e-05 | 5.4252e-05 | 5.4252e-05 |   0.0 |  0.00
Modify  | 0.12261    | 0.12261    | 0.12261    |   0.0 |  0.16
Other   |            | 0.01094    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6116 ave        6116 max        6116 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541008 ave      541008 max      541008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541008
Ave neighs/atom = 135.252
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.891204543202, Press = -4.03865808588133
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17521.597     -17521.597     -17660.261     -17660.261      268.25535      268.25535      44112.123      44112.123     -1241.1396     -1241.1396    
     15000  -17515.413     -17515.413     -17657.485     -17657.485      274.84807      274.84807      44054.984      44054.984      1481.8079      1481.8079    
Loop time of 75.6542 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.142 ns/day, 21.015 hours/ns, 13.218 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    | 75.498     | 75.498     | 75.498     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022739   | 0.022739   | 0.022739   |   0.0 |  0.03
Output  | 5.6766e-05 | 5.6766e-05 | 5.6766e-05 |   0.0 |  0.00
Modify  | 0.12249    | 0.12249    | 0.12249    |   0.0 |  0.16
Other   |            | 0.01083    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6158 ave        6158 max        6158 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540958 ave      540958 max      540958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540958
Ave neighs/atom = 135.2395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.821574967446, Press = -2.96857562784229
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17515.413     -17515.413     -17657.485     -17657.485      274.84807      274.84807      44054.984      44054.984      1481.8079      1481.8079    
     16000  -17518.966     -17518.966     -17658.693     -17658.693      270.31098      270.31098      44095.436      44095.436     -388.31577     -388.31577    
Loop time of 75.7334 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.037 hours/ns, 13.204 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    | 75.577     | 75.577     | 75.577     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022574   | 0.022574   | 0.022574   |   0.0 |  0.03
Output  | 6.92e-05   | 6.92e-05   | 6.92e-05   |   0.0 |  0.00
Modify  | 0.12261    | 0.12261    | 0.12261    |   0.0 |  0.16
Other   |            | 0.01091    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6150 ave        6150 max        6150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541130 ave      541130 max      541130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541130
Ave neighs/atom = 135.2825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.698262205951, Press = 3.25928020505483
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     16000  -17518.966     -17518.966     -17658.693     -17658.693      270.31098      270.31098      44095.436      44095.436     -388.31577     -388.31577    
     17000  -17517.193     -17517.193     -17654.257     -17654.257      265.15997      265.15997      44150.905      44150.905     -2328.4121     -2328.4121    
Loop time of 75.6009 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.143 ns/day, 21.000 hours/ns, 13.227 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    | 75.445     | 75.445     | 75.445     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022623   | 0.022623   | 0.022623   |   0.0 |  0.03
Output  | 7.6143e-05 | 7.6143e-05 | 7.6143e-05 |   0.0 |  0.00
Modify  | 0.12271    | 0.12271    | 0.12271    |   0.0 |  0.16
Other   |            | 0.01091    |            |       |  0.01

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:       540996 ave      540996 max      540996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540996
Ave neighs/atom = 135.249
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.695398117188, Press = -5.06657166352011
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17517.193     -17517.193     -17654.257     -17654.257      265.15997      265.15997      44150.905      44150.905     -2328.4121     -2328.4121    
     18000  -17517.115     -17517.115     -17658.522     -17658.522      273.56007      273.56007      44024.567      44024.567      2663.1296      2663.1296    
Loop time of 75.8008 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.140 ns/day, 21.056 hours/ns, 13.192 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    | 75.645     | 75.645     | 75.645     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02253    | 0.02253    | 0.02253    |   0.0 |  0.03
Output  | 5.7939e-05 | 5.7939e-05 | 5.7939e-05 |   0.0 |  0.00
Modify  | 0.12249    | 0.12249    | 0.12249    |   0.0 |  0.16
Other   |            | 0.01091    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6129 ave        6129 max        6129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540870 ave      540870 max      540870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540870
Ave neighs/atom = 135.2175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.564323491124, Press = -3.03550389461198
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17517.115     -17517.115     -17658.522     -17658.522      273.56007      273.56007      44024.567      44024.567      2663.1296      2663.1296    
     19000  -17518.016     -17518.016     -17661.742     -17661.742      278.04891      278.04891      44086.425      44086.425     -224.95585     -224.95585    
Loop time of 75.8126 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.140 ns/day, 21.059 hours/ns, 13.190 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    | 75.657     | 75.657     | 75.657     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022444   | 0.022444   | 0.022444   |   0.0 |  0.03
Output  | 6.9891e-05 | 6.9891e-05 | 6.9891e-05 |   0.0 |  0.00
Modify  | 0.12253    | 0.12253    | 0.12253    |   0.0 |  0.16
Other   |            | 0.01091    |            |       |  0.01

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:       541332 ave      541332 max      541332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541332
Ave neighs/atom = 135.333
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.634778943031, Press = 1.68806156948834
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     19000  -17518.016     -17518.016     -17661.742     -17661.742      278.04891      278.04891      44086.425      44086.425     -224.95585     -224.95585    
     20000  -17514.638     -17514.638     -17659.818     -17659.818      280.86042      280.86042      44118.106      44118.106     -1287.0412     -1287.0412    
Loop time of 75.7873 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.140 ns/day, 21.052 hours/ns, 13.195 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    | 75.631     | 75.631     | 75.631     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022624   | 0.022624   | 0.022624   |   0.0 |  0.03
Output  | 6.2167e-05 | 6.2167e-05 | 6.2167e-05 |   0.0 |  0.00
Modify  | 0.12271    | 0.12271    | 0.12271    |   0.0 |  0.16
Other   |            | 0.01093    |            |       |  0.01

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:       541004 ave      541004 max      541004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541004
Ave neighs/atom = 135.251
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.620312232864, Press = -1.03500345479308
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     20000  -17514.638     -17514.638     -17659.818     -17659.818      280.86042      280.86042      44118.106      44118.106     -1287.0412     -1287.0412    
     21000  -17517.951     -17517.951     -17657.075     -17657.075      269.14528      269.14528      44066.666      44066.666      1025.8604      1025.8604    
Loop time of 75.7943 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.140 ns/day, 21.054 hours/ns, 13.194 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    | 75.638     | 75.638     | 75.638     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022612   | 0.022612   | 0.022612   |   0.0 |  0.03
Output  | 5.6656e-05 | 5.6656e-05 | 5.6656e-05 |   0.0 |  0.00
Modify  | 0.12278    | 0.12278    | 0.12278    |   0.0 |  0.16
Other   |            | 0.01088    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6085 ave        6085 max        6085 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540910 ave      540910 max      540910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540910
Ave neighs/atom = 135.2275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.550997535602, Press = -1.46357644857743
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     21000  -17517.951     -17517.951     -17657.075     -17657.075      269.14528      269.14528      44066.666      44066.666      1025.8604      1025.8604    
     22000  -17517.138     -17517.138     -17658.159     -17658.159      272.8158       272.8158       44070.771      44070.771      791.96485      791.96485    
Loop time of 75.5989 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.143 ns/day, 21.000 hours/ns, 13.228 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    | 75.443     | 75.443     | 75.443     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022684   | 0.022684   | 0.022684   |   0.0 |  0.03
Output  | 5.311e-05  | 5.311e-05  | 5.311e-05  |   0.0 |  0.00
Modify  | 0.12245    | 0.12245    | 0.12245    |   0.0 |  0.16
Other   |            | 0.01094    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6144 ave        6144 max        6144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541080 ave      541080 max      541080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541080
Ave neighs/atom = 135.27
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.622637225141, Press = 2.74306502081128
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17517.138     -17517.138     -17658.159     -17658.159      272.8158       272.8158       44070.771      44070.771      791.96485      791.96485    
     23000  -17513.851     -17513.851     -17655.461     -17655.461      273.95526      273.95526      44176.586      44176.586     -3264.7197     -3264.7197    
Loop time of 75.7116 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.031 hours/ns, 13.208 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    | 75.555     | 75.555     | 75.555     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022761   | 0.022761   | 0.022761   |   0.0 |  0.03
Output  | 5.326e-05  | 5.326e-05  | 5.326e-05  |   0.0 |  0.00
Modify  | 0.12261    | 0.12261    | 0.12261    |   0.0 |  0.16
Other   |            | 0.01087    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6129 ave        6129 max        6129 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541056 ave      541056 max      541056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541056
Ave neighs/atom = 135.264
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.620697633857, Press = -1.2137850759373
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     23000  -17513.851     -17513.851     -17655.461     -17655.461      273.95526      273.95526      44176.586      44176.586     -3264.7197     -3264.7197    
     24000  -17521.522     -17521.522     -17659.385     -17659.385      266.7062       266.7062       44055.117      44055.117      1236.711       1236.711     
Loop time of 75.7199 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.033 hours/ns, 13.207 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    | 75.564     | 75.564     | 75.564     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022612   | 0.022612   | 0.022612   |   0.0 |  0.03
Output  | 6.7667e-05 | 6.7667e-05 | 6.7667e-05 |   0.0 |  0.00
Modify  | 0.12248    | 0.12248    | 0.12248    |   0.0 |  0.16
Other   |            | 0.01084    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6133 ave        6133 max        6133 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540598 ave      540598 max      540598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540598
Ave neighs/atom = 135.1495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.560336020767, Press = -2.42273573406216
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17521.522     -17521.522     -17659.385     -17659.385      266.7062       266.7062       44055.117      44055.117      1236.711       1236.711     
     25000  -17513.725     -17513.725     -17656.967     -17656.967      277.11246      277.11246      44079.274      44079.274      632.20913      632.20913    
Loop time of 75.6886 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.142 ns/day, 21.025 hours/ns, 13.212 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    | 75.533     | 75.533     | 75.533     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022425   | 0.022425   | 0.022425   |   0.0 |  0.03
Output  | 7.1474e-05 | 7.1474e-05 | 7.1474e-05 |   0.0 |  0.00
Modify  | 0.1225     | 0.1225     | 0.1225     |   0.0 |  0.16
Other   |            | 0.01089    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6076 ave        6076 max        6076 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541146 ave      541146 max      541146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541146
Ave neighs/atom = 135.2865
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.58340866179, Press = 1.55616415684174
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17513.725     -17513.725     -17656.967     -17656.967      277.11246      277.11246      44079.274      44079.274      632.20913      632.20913    
     26000  -17519.976     -17519.976     -17659.598     -17659.598      270.10879      270.10879      44116.262      44116.262     -1284.3809     -1284.3809    
Loop time of 75.6295 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.142 ns/day, 21.008 hours/ns, 13.222 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    | 75.473     | 75.473     | 75.473     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022739   | 0.022739   | 0.022739   |   0.0 |  0.03
Output  | 6.1606e-05 | 6.1606e-05 | 6.1606e-05 |   0.0 |  0.00
Modify  | 0.12256    | 0.12256    | 0.12256    |   0.0 |  0.16
Other   |            | 0.01083    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6157 ave        6157 max        6157 min
Histogram: 1 0 0 0 0 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 = 272.58332099776, Press = -0.52527636598287
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17519.976     -17519.976     -17659.598     -17659.598      270.10879      270.10879      44116.262      44116.262     -1284.3809     -1284.3809    
     27000  -17513.854     -17513.854     -17655.099     -17655.099      273.24786      273.24786      44089.538      44089.538      305.91881      305.91881    
Loop time of 75.4774 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.145 ns/day, 20.966 hours/ns, 13.249 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    | 75.321     | 75.321     | 75.321     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022593   | 0.022593   | 0.022593   |   0.0 |  0.03
Output  | 5.9151e-05 | 5.9151e-05 | 5.9151e-05 |   0.0 |  0.00
Modify  | 0.12259    | 0.12259    | 0.12259    |   0.0 |  0.16
Other   |            | 0.0109     |            |       |  0.01

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:       540830 ave      540830 max      540830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540830
Ave neighs/atom = 135.2075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.584098883813, Press = -1.66653327259733
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17513.854     -17513.854     -17655.099     -17655.099      273.24786      273.24786      44089.538      44089.538      305.91881      305.91881    
     28000  -17516.954     -17516.954     -17659.895     -17659.895      276.52792      276.52792      44071.125      44071.125      639.99317      639.99317    
Loop time of 75.5773 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.143 ns/day, 20.994 hours/ns, 13.231 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    | 75.422     | 75.422     | 75.422     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022525   | 0.022525   | 0.022525   |   0.0 |  0.03
Output  | 6.1435e-05 | 6.1435e-05 | 6.1435e-05 |   0.0 |  0.00
Modify  | 0.12242    | 0.12242    | 0.12242    |   0.0 |  0.16
Other   |            | 0.01079    |            |       |  0.01

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:       541058 ave      541058 max      541058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541058
Ave neighs/atom = 135.2645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.685646686416, Press = 1.2490770943363
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17516.954     -17516.954     -17659.895     -17659.895      276.52792      276.52792      44071.125      44071.125      639.99317      639.99317    
     29000  -17512.768     -17512.768     -17655.794     -17655.794      276.69403      276.69403      44171.91       44171.91      -3084.2904     -3084.2904    
Loop time of 75.7299 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.036 hours/ns, 13.205 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    | 75.574     | 75.574     | 75.574     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022444   | 0.022444   | 0.022444   |   0.0 |  0.03
Output  | 7.7055e-05 | 7.7055e-05 | 7.7055e-05 |   0.0 |  0.00
Modify  | 0.12241    | 0.12241    | 0.12241    |   0.0 |  0.16
Other   |            | 0.01089    |            |       |  0.01

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:       541038 ave      541038 max      541038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541038
Ave neighs/atom = 135.2595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.744027805895, Press = -0.461560761290114
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17512.768     -17512.768     -17655.794     -17655.794      276.69403      276.69403      44171.91       44171.91      -3084.2904     -3084.2904    
     30000  -17517.316     -17517.316     -17658.278     -17658.278      272.70029      272.70029      44071.177      44071.177      695.24136      695.24136    
Loop time of 75.6844 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.142 ns/day, 21.023 hours/ns, 13.213 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    | 75.528     | 75.528     | 75.528     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022467   | 0.022467   | 0.022467   |   0.0 |  0.03
Output  | 5.898e-05  | 5.898e-05  | 5.898e-05  |   0.0 |  0.00
Modify  | 0.12262    | 0.12262    | 0.12262    |   0.0 |  0.16
Other   |            | 0.0109     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6126 ave        6126 max        6126 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540614 ave      540614 max      540614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540614
Ave neighs/atom = 135.1535
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.758342704989, Press = -2.00072638885951
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17517.316     -17517.316     -17658.278     -17658.278      272.70029      272.70029      44071.177      44071.177      695.24136      695.24136    
     31000  -17515.191     -17515.191     -17657.932     -17657.932      276.14166      276.14166      44076.509      44076.509      604.70368      604.70368    
Loop time of 75.645 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.142 ns/day, 21.012 hours/ns, 13.220 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    | 75.489     | 75.489     | 75.489     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022478   | 0.022478   | 0.022478   |   0.0 |  0.03
Output  | 6.7166e-05 | 6.7166e-05 | 6.7166e-05 |   0.0 |  0.00
Modify  | 0.12262    | 0.12262    | 0.12262    |   0.0 |  0.16
Other   |            | 0.01098    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6110 ave        6110 max        6110 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540958 ave      540958 max      540958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540958
Ave neighs/atom = 135.2395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.768792019889, Press = 0.512221957182465
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17515.191     -17515.191     -17657.932     -17657.932      276.14166      276.14166      44076.509      44076.509      604.70368      604.70368    
     32000  -17520.072     -17520.072     -17661.54      -17661.54       273.68008      273.68008      44109.228      44109.228     -1176.9947     -1176.9947    
Loop time of 75.8166 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.140 ns/day, 21.060 hours/ns, 13.190 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    | 75.66      | 75.66      | 75.66      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022728   | 0.022728   | 0.022728   |   0.0 |  0.03
Output  | 5.3791e-05 | 5.3791e-05 | 5.3791e-05 |   0.0 |  0.00
Modify  | 0.1225     | 0.1225     | 0.1225     |   0.0 |  0.16
Other   |            | 0.01084    |            |       |  0.01

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:       541006 ave      541006 max      541006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541006
Ave neighs/atom = 135.2515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.735665573592, Press = -0.211074326581233
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17520.072     -17520.072     -17661.54      -17661.54       273.68008      273.68008      44109.228      44109.228     -1176.9947     -1176.9947    
     33000  -17514.532     -17514.532     -17656.975     -17656.975      275.56711      275.56711      44087.904      44087.904      221.42592      221.42592    
Loop time of 75.8122 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.140 ns/day, 21.059 hours/ns, 13.190 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    | 75.656     | 75.656     | 75.656     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022544   | 0.022544   | 0.022544   |   0.0 |  0.03
Output  | 4.5576e-05 | 4.5576e-05 | 4.5576e-05 |   0.0 |  0.00
Modify  | 0.1224     | 0.1224     | 0.1224     |   0.0 |  0.16
Other   |            | 0.01102    |            |       |  0.01

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:       540920 ave      540920 max      540920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540920
Ave neighs/atom = 135.23
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.723136460542, Press = -1.54699663576409
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17514.532     -17514.532     -17656.975     -17656.975      275.56711      275.56711      44087.904      44087.904      221.42592      221.42592    
     34000  -17520.383     -17520.383     -17659.255     -17659.255      268.65722      268.65722      43996.671      43996.671      3648.6411      3648.6411    
Loop time of 75.7381 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.038 hours/ns, 13.203 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    | 75.582     | 75.582     | 75.582     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022537   | 0.022537   | 0.022537   |   0.0 |  0.03
Output  | 5.4593e-05 | 5.4593e-05 | 5.4593e-05 |   0.0 |  0.00
Modify  | 0.12243    | 0.12243    | 0.12243    |   0.0 |  0.16
Other   |            | 0.01101    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6127 ave        6127 max        6127 min
Histogram: 1 0 0 0 0 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 = 272.697710826043, Press = 2.03292824059946
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17520.383     -17520.383     -17659.255     -17659.255      268.65722      268.65722      43996.671      43996.671      3648.6411      3648.6411    
     35000  -17518.557     -17518.557     -17656.394     -17656.394      266.65509      266.65509      44148.036      44148.036     -2267.9808     -2267.9808    
Loop time of 75.673 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.142 ns/day, 21.020 hours/ns, 13.215 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    | 75.517     | 75.517     | 75.517     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022774   | 0.022774   | 0.022774   |   0.0 |  0.03
Output  | 5.8921e-05 | 5.8921e-05 | 5.8921e-05 |   0.0 |  0.00
Modify  | 0.12256    | 0.12256    | 0.12256    |   0.0 |  0.16
Other   |            | 0.01087    |            |       |  0.01

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:       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 = 272.714067798318, Press = 0.996931958459139
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17518.557     -17518.557     -17656.394     -17656.394      266.65509      266.65509      44148.036      44148.036     -2267.9808     -2267.9808    
     36000  -17516.886     -17516.886     -17659.513     -17659.513      275.92207      275.92207      44094.328      44094.328     -288.77815     -288.77815    
Loop time of 75.473 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.145 ns/day, 20.965 hours/ns, 13.250 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    | 75.317     | 75.317     | 75.317     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022541   | 0.022541   | 0.022541   |   0.0 |  0.03
Output  | 5.4141e-05 | 5.4141e-05 | 5.4141e-05 |   0.0 |  0.00
Modify  | 0.12248    | 0.12248    | 0.12248    |   0.0 |  0.16
Other   |            | 0.011      |            |       |  0.01

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:       540758 ave      540758 max      540758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540758
Ave neighs/atom = 135.1895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.742252177527, Press = -1.40137560323066
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17516.886     -17516.886     -17659.513     -17659.513      275.92207      275.92207      44094.328      44094.328     -288.77815     -288.77815    
     37000  -17514.064     -17514.064     -17654.581     -17654.581      271.83981      271.83981      44066.499      44066.499      1241.0756      1241.0756    
Loop time of 75.652 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.142 ns/day, 21.014 hours/ns, 13.218 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    | 75.496     | 75.496     | 75.496     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02268    | 0.02268    | 0.02268    |   0.0 |  0.03
Output  | 5.1707e-05 | 5.1707e-05 | 5.1707e-05 |   0.0 |  0.00
Modify  | 0.1226     | 0.1226     | 0.1226     |   0.0 |  0.16
Other   |            | 0.01083    |            |       |  0.01

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:       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 = 272.780791138157, Press = 0.632288212473753
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17514.064     -17514.064     -17654.581     -17654.581      271.83981      271.83981      44066.499      44066.499      1241.0756      1241.0756    
     38000  -17516.69      -17516.69      -17656.821     -17656.821      271.09111      271.09111      44121.478      44121.478     -1200.745      -1200.745     
Loop time of 75.6206 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.143 ns/day, 21.006 hours/ns, 13.224 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    | 75.465     | 75.465     | 75.465     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022572   | 0.022572   | 0.022572   |   0.0 |  0.03
Output  | 4.9403e-05 | 4.9403e-05 | 4.9403e-05 |   0.0 |  0.00
Modify  | 0.12241    | 0.12241    | 0.12241    |   0.0 |  0.16
Other   |            | 0.01101    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6150 ave        6150 max        6150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541238 ave      541238 max      541238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541238
Ave neighs/atom = 135.3095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.799320302594, Press = 0.359195037345574
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17516.69      -17516.69      -17656.821     -17656.821      271.09111      271.09111      44121.478      44121.478     -1200.745      -1200.745     
     39000  -17515.507     -17515.507     -17657.515     -17657.515      274.72473      274.72473      44101.53       44101.53      -400.91319     -400.91319    
Loop time of 75.5536 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.144 ns/day, 20.987 hours/ns, 13.236 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    | 75.398     | 75.398     | 75.398     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022804   | 0.022804   | 0.022804   |   0.0 |  0.03
Output  | 5.2649e-05 | 5.2649e-05 | 5.2649e-05 |   0.0 |  0.00
Modify  | 0.12237    | 0.12237    | 0.12237    |   0.0 |  0.16
Other   |            | 0.01081    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6199 ave        6199 max        6199 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540928 ave      540928 max      540928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540928
Ave neighs/atom = 135.232
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.814612417142, Press = -1.05171275595791
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     39000  -17515.507     -17515.507     -17657.515     -17657.515      274.72473      274.72473      44101.53       44101.53      -400.91319     -400.91319    
     40000  -17510.038     -17510.038     -17654.323     -17654.323      279.13059      279.13059      44077.38       44077.38       988.19648      988.19648    
Loop time of 75.6095 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.143 ns/day, 21.003 hours/ns, 13.226 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    | 75.453     | 75.453     | 75.453     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022441   | 0.022441   | 0.022441   |   0.0 |  0.03
Output  | 6.7016e-05 | 6.7016e-05 | 6.7016e-05 |   0.0 |  0.00
Modify  | 0.12256    | 0.12256    | 0.12256    |   0.0 |  0.16
Other   |            | 0.01097    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6064 ave        6064 max        6064 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541050 ave      541050 max      541050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541050
Ave neighs/atom = 135.2625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.844083604523, Press = 0.468785275091024
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17510.038     -17510.038     -17654.323     -17654.323      279.13059      279.13059      44077.38       44077.38       988.19648      988.19648    
     41000  -17518.255     -17518.255     -17659.5       -17659.5        273.2481       273.2481       44124.496      44124.496     -1581.854      -1581.854     
Loop time of 75.5833 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.143 ns/day, 20.995 hours/ns, 13.230 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    | 75.427     | 75.427     | 75.427     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022764   | 0.022764   | 0.022764   |   0.0 |  0.03
Output  | 5.5764e-05 | 5.5764e-05 | 5.5764e-05 |   0.0 |  0.00
Modify  | 0.12248    | 0.12248    | 0.12248    |   0.0 |  0.16
Other   |            | 0.01086    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6177 ave        6177 max        6177 min
Histogram: 1 0 0 0 0 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 = 272.874871395081, Press = 0.0382979411616537
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17518.255     -17518.255     -17659.5       -17659.5        273.2481       273.2481       44124.496      44124.496     -1581.854      -1581.854     
     42000  -17513.415     -17513.415     -17655.387     -17655.387      274.65333      274.65333      44091.129      44091.129      139.73014      139.73014    
Loop time of 75.682 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.142 ns/day, 21.023 hours/ns, 13.213 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    | 75.526     | 75.526     | 75.526     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02246    | 0.02246    | 0.02246    |   0.0 |  0.03
Output  | 5.4733e-05 | 5.4733e-05 | 5.4733e-05 |   0.0 |  0.00
Modify  | 0.12256    | 0.12256    | 0.12256    |   0.0 |  0.16
Other   |            | 0.01102    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6106 ave        6106 max        6106 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540892 ave      540892 max      540892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540892
Ave neighs/atom = 135.223
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.87100382997, Press = -2.05865475449142
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     42000  -17513.415     -17513.415     -17655.387     -17655.387      274.65333      274.65333      44091.129      44091.129      139.73014      139.73014    
     43000  -17517.241     -17517.241     -17658.546     -17658.546      273.36588      273.36588      44037.04       44037.04       2114.9736      2114.9736    
Loop time of 75.7094 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.030 hours/ns, 13.208 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    | 75.553     | 75.553     | 75.553     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022838   | 0.022838   | 0.022838   |   0.0 |  0.03
Output  | 5.839e-05  | 5.839e-05  | 5.839e-05  |   0.0 |  0.00
Modify  | 0.12266    | 0.12266    | 0.12266    |   0.0 |  0.16
Other   |            | 0.01082    |            |       |  0.01

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:       541224 ave      541224 max      541224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541224
Ave neighs/atom = 135.306
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.843686945935, Press = 0.948584494597436
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -17517.241     -17517.241     -17658.546     -17658.546      273.36588      273.36588      44037.04       44037.04       2114.9736      2114.9736    
     44000  -17517.081     -17517.081     -17659.623     -17659.623      275.75654      275.75654      44110.272      44110.272     -1027.685      -1027.685     
Loop time of 75.5585 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.143 ns/day, 20.988 hours/ns, 13.235 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    | 75.402     | 75.402     | 75.402     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022725   | 0.022725   | 0.022725   |   0.0 |  0.03
Output  | 7.3728e-05 | 7.3728e-05 | 7.3728e-05 |   0.0 |  0.00
Modify  | 0.12272    | 0.12272    | 0.12272    |   0.0 |  0.16
Other   |            | 0.01103    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6160 ave        6160 max        6160 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541320 ave      541320 max      541320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541320
Ave neighs/atom = 135.33
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.848657357854, Press = 0.244231543210503
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -17517.081     -17517.081     -17659.623     -17659.623      275.75654      275.75654      44110.272      44110.272     -1027.685      -1027.685     
     45000  -17519.628     -17519.628     -17656.965     -17656.965      265.6884       265.6884       44088.917      44088.917      55.146853      55.146853    
Loop time of 75.7372 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.038 hours/ns, 13.204 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    | 75.581     | 75.581     | 75.581     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022605   | 0.022605   | 0.022605   |   0.0 |  0.03
Output  | 0.00011025 | 0.00011025 | 0.00011025 |   0.0 |  0.00
Modify  | 0.12272    | 0.12272    | 0.12272    |   0.0 |  0.16
Other   |            | 0.01081    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6150 ave        6150 max        6150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540938 ave      540938 max      540938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540938
Ave neighs/atom = 135.2345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.803102145509, Press = -0.58223419102745
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -17519.628     -17519.628     -17656.965     -17656.965      265.6884       265.6884       44088.917      44088.917      55.146853      55.146853    
     46000  -17517.39      -17517.39      -17658.599     -17658.599      273.17894      273.17894      44059.761      44059.761      1151.3794      1151.3794    
Loop time of 75.6476 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.142 ns/day, 21.013 hours/ns, 13.219 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    | 75.491     | 75.491     | 75.491     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022603   | 0.022603   | 0.022603   |   0.0 |  0.03
Output  | 4.9884e-05 | 4.9884e-05 | 4.9884e-05 |   0.0 |  0.00
Modify  | 0.12277    | 0.12277    | 0.12277    |   0.0 |  0.16
Other   |            | 0.01102    |            |       |  0.01

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:       541098 ave      541098 max      541098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541098
Ave neighs/atom = 135.2745
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.806889722813, Press = 0.20491008059513
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -17517.39      -17517.39      -17658.599     -17658.599      273.17894      273.17894      44059.761      44059.761      1151.3794      1151.3794    
     47000  -17513.906     -17513.906     -17660.031     -17660.031      282.68839      282.68839      44129.591      44129.591     -1744.4428     -1744.4428    
Loop time of 75.5133 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.144 ns/day, 20.976 hours/ns, 13.243 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    | 75.357     | 75.357     | 75.357     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022596   | 0.022596   | 0.022596   |   0.0 |  0.03
Output  | 5.0374e-05 | 5.0374e-05 | 5.0374e-05 |   0.0 |  0.00
Modify  | 0.12263    | 0.12263    | 0.12263    |   0.0 |  0.16
Other   |            | 0.01085    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6149 ave        6149 max        6149 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541074 ave      541074 max      541074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541074
Ave neighs/atom = 135.2685
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.794660155033, Press = 0.535915761214703
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -17513.906     -17513.906     -17660.031     -17660.031      282.68839      282.68839      44129.591      44129.591     -1744.4428     -1744.4428    
     48000  -17521.023     -17521.023     -17659.954     -17659.954      268.77098      268.77098      44115.955      44115.955     -1318.1452     -1318.1452    
Loop time of 75.6928 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.026 hours/ns, 13.211 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    | 75.536     | 75.536     | 75.536     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022607   | 0.022607   | 0.022607   |   0.0 |  0.03
Output  | 5.2789e-05 | 5.2789e-05 | 5.2789e-05 |   0.0 |  0.00
Modify  | 0.12269    | 0.12269    | 0.12269    |   0.0 |  0.16
Other   |            | 0.01106    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6137 ave        6137 max        6137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540772 ave      540772 max      540772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540772
Ave neighs/atom = 135.193
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.784261910524, Press = -1.99952020453873
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -17521.023     -17521.023     -17659.954     -17659.954      268.77098      268.77098      44115.955      44115.955     -1318.1452     -1318.1452    
     49000  -17515.968     -17515.968     -17657.019     -17657.019      272.87274      272.87274      44003.003      44003.003      3685.7007      3685.7007    
Loop time of 75.4237 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.146 ns/day, 20.951 hours/ns, 13.258 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    | 75.267     | 75.267     | 75.267     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022654   | 0.022654   | 0.022654   |   0.0 |  0.03
Output  | 5.3421e-05 | 5.3421e-05 | 5.3421e-05 |   0.0 |  0.00
Modify  | 0.1227     | 0.1227     | 0.1227     |   0.0 |  0.16
Other   |            | 0.01085    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6138 ave        6138 max        6138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540916 ave      540916 max      540916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540916
Ave neighs/atom = 135.229
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.773761741225, Press = 0.348728570546839
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -17515.968     -17515.968     -17657.019     -17657.019      272.87274      272.87274      44003.003      44003.003      3685.7007      3685.7007    
     50000  -17511.054     -17511.054     -17652.548     -17652.548      273.73083      273.73083      44121.995      44121.995     -772.6937      -772.6937     
Loop time of 75.7486 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.041 hours/ns, 13.202 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    | 75.592     | 75.592     | 75.592     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022905   | 0.022905   | 0.022905   |   0.0 |  0.03
Output  | 5.2519e-05 | 5.2519e-05 | 5.2519e-05 |   0.0 |  0.00
Modify  | 0.12264    | 0.12264    | 0.12264    |   0.0 |  0.16
Other   |            | 0.01103    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6233 ave        6233 max        6233 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541378 ave      541378 max      541378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541378
Ave neighs/atom = 135.3445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.769240261808, Press = 0.685514434938311
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -17511.054     -17511.054     -17652.548     -17652.548      273.73083      273.73083      44121.995      44121.995     -772.6937      -772.6937     
     51000  -17517.069     -17517.069     -17656.952     -17656.952      270.61299      270.61299      44103.439      44103.439     -463.25362     -463.25362    
Loop time of 75.573 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.143 ns/day, 20.993 hours/ns, 13.232 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    | 75.417     | 75.417     | 75.417     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022413   | 0.022413   | 0.022413   |   0.0 |  0.03
Output  | 5.891e-05  | 5.891e-05  | 5.891e-05  |   0.0 |  0.00
Modify  | 0.12263    | 0.12263    | 0.12263    |   0.0 |  0.16
Other   |            | 0.01097    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6086 ave        6086 max        6086 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541004 ave      541004 max      541004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541004
Ave neighs/atom = 135.251
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.793535715056, Press = -0.557398398827593
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -17517.069     -17517.069     -17656.952     -17656.952      270.61299      270.61299      44103.439      44103.439     -463.25362     -463.25362    
     52000  -17510.824     -17510.824     -17653.671     -17653.671      276.34763      276.34763      44070.427      44070.427      1269.9823      1269.9823    
Loop time of 75.6504 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.142 ns/day, 21.014 hours/ns, 13.219 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    | 75.494     | 75.494     | 75.494     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022618   | 0.022618   | 0.022618   |   0.0 |  0.03
Output  | 6.4962e-05 | 6.4962e-05 | 6.4962e-05 |   0.0 |  0.00
Modify  | 0.12251    | 0.12251    | 0.12251    |   0.0 |  0.16
Other   |            | 0.01101    |            |       |  0.01

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:       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 = 272.837507552167, Press = 0.0672263058423444
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -17510.824     -17510.824     -17653.671     -17653.671      276.34763      276.34763      44070.427      44070.427      1269.9823      1269.9823    
     53000  -17517.218     -17517.218     -17658.862     -17658.862      274.02064      274.02064      44104.904      44104.904     -700.64761     -700.64761    
Loop time of 75.7329 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.037 hours/ns, 13.204 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    | 75.576     | 75.576     | 75.576     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022596   | 0.022596   | 0.022596   |   0.0 |  0.03
Output  | 4.9413e-05 | 4.9413e-05 | 4.9413e-05 |   0.0 |  0.00
Modify  | 0.12281    | 0.12281    | 0.12281    |   0.0 |  0.16
Other   |            | 0.01106    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6144 ave        6144 max        6144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541216 ave      541216 max      541216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541216
Ave neighs/atom = 135.304
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.860358538481, Press = 0.946636249699059
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -17517.218     -17517.218     -17658.862     -17658.862      274.02064      274.02064      44104.904      44104.904     -700.64761     -700.64761    
     54000  -17520.282     -17520.282     -17658.424     -17658.424      267.24383      267.24383      44119.911      44119.911     -1371.9943     -1371.9943    
Loop time of 75.6052 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.143 ns/day, 21.001 hours/ns, 13.227 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    | 75.449     | 75.449     | 75.449     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022703   | 0.022703   | 0.022703   |   0.0 |  0.03
Output  | 6.7276e-05 | 6.7276e-05 | 6.7276e-05 |   0.0 |  0.00
Modify  | 0.1227     | 0.1227     | 0.1227     |   0.0 |  0.16
Other   |            | 0.01087    |            |       |  0.01

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:       540976 ave      540976 max      540976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540976
Ave neighs/atom = 135.244
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.867971182919, Press = -1.18452614160889
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -17520.282     -17520.282     -17658.424     -17658.424      267.24383      267.24383      44119.911      44119.911     -1371.9943     -1371.9943    
     55000  -17513.966     -17513.966     -17654.768     -17654.768      272.39015      272.39015      44031.05       44031.05       2740.0202      2740.0202    
Loop time of 75.6715 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.142 ns/day, 21.020 hours/ns, 13.215 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    | 75.515     | 75.515     | 75.515     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022519   | 0.022519   | 0.022519   |   0.0 |  0.03
Output  | 6.6715e-05 | 6.6715e-05 | 6.6715e-05 |   0.0 |  0.00
Modify  | 0.12277    | 0.12277    | 0.12277    |   0.0 |  0.16
Other   |            | 0.01099    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6096 ave        6096 max        6096 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540912 ave      540912 max      540912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540912
Ave neighs/atom = 135.228
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.879868760516, Press = 0.0453012238582861
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.375 | 5.375 | 5.375 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -17513.966     -17513.966     -17654.768     -17654.768      272.39015      272.39015      44031.05       44031.05       2740.0202      2740.0202    
     56000  -17512.247     -17512.247     -17656.215     -17656.215      278.51536      278.51536      44108.288      44108.288     -551.99163     -551.99163    
Loop time of 75.7144 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.032 hours/ns, 13.208 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    | 75.558     | 75.558     | 75.558     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022777   | 0.022777   | 0.022777   |   0.0 |  0.03
Output  | 7.0222e-05 | 7.0222e-05 | 7.0222e-05 |   0.0 |  0.00
Modify  | 0.12265    | 0.12265    | 0.12265    |   0.0 |  0.16
Other   |            | 0.01083    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6228 ave        6228 max        6228 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541324 ave      541324 max      541324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541324
Ave neighs/atom = 135.331
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.891159310477, Press = 0.574158045950158
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -17512.247     -17512.247     -17656.215     -17656.215      278.51536      278.51536      44108.288      44108.288     -551.99163     -551.99163    
     57000  -17517.245     -17517.245     -17658.631     -17658.631      273.52044      273.52044      44103.923      44103.923     -753.47431     -753.47431    
Loop time of 75.7447 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.040 hours/ns, 13.202 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    | 75.588     | 75.588     | 75.588     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022605   | 0.022605   | 0.022605   |   0.0 |  0.03
Output  | 5.8169e-05 | 5.8169e-05 | 5.8169e-05 |   0.0 |  0.00
Modify  | 0.1225     | 0.1225     | 0.1225     |   0.0 |  0.16
Other   |            | 0.01108    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6160 ave        6160 max        6160 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540892 ave      540892 max      540892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540892
Ave neighs/atom = 135.223
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.93486696452, Press = -0.3037892864791
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -17517.245     -17517.245     -17658.631     -17658.631      273.52044      273.52044      44103.923      44103.923     -753.47431     -753.47431    
     58000  -17513.617     -17513.617     -17656.676     -17656.676      276.7575       276.7575       44067.027      44067.027      1070.3972      1070.3972    
Loop time of 75.7547 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.043 hours/ns, 13.200 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    | 75.599     | 75.599     | 75.599     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022503   | 0.022503   | 0.022503   |   0.0 |  0.03
Output  | 6.6515e-05 | 6.6515e-05 | 6.6515e-05 |   0.0 |  0.00
Modify  | 0.12271    | 0.12271    | 0.12271    |   0.0 |  0.16
Other   |            | 0.0109     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6133 ave        6133 max        6133 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540884 ave      540884 max      540884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540884
Ave neighs/atom = 135.221
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.950215092604, Press = -0.267417050461946
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -17513.617     -17513.617     -17656.676     -17656.676      276.7575       276.7575       44067.027      44067.027      1070.3972      1070.3972    
     59000  -17518.939     -17518.939     -17659.523     -17659.523      271.96947      271.96947      44087.529      44087.529     -80.092027     -80.092027    
Loop time of 75.6252 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.142 ns/day, 21.007 hours/ns, 13.223 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    | 75.469     | 75.469     | 75.469     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022471   | 0.022471   | 0.022471   |   0.0 |  0.03
Output  | 5.324e-05  | 5.324e-05  | 5.324e-05  |   0.0 |  0.00
Modify  | 0.12263    | 0.12263    | 0.12263    |   0.0 |  0.16
Other   |            | 0.011      |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6137 ave        6137 max        6137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541126 ave      541126 max      541126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541126
Ave neighs/atom = 135.2815
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.960123247803, Press = 0.917944077264744
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -17518.939     -17518.939     -17659.523     -17659.523      271.96947      271.96947      44087.529      44087.529     -80.092027     -80.092027    
     60000  -17518.045     -17518.045     -17659.351     -17659.351      273.36575      273.36575      44173.647      44173.647     -3625.9213     -3625.9213    
Loop time of 75.7455 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.040 hours/ns, 13.202 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    | 75.589     | 75.589     | 75.589     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022667   | 0.022667   | 0.022667   |   0.0 |  0.03
Output  | 5.7318e-05 | 5.7318e-05 | 5.7318e-05 |   0.0 |  0.00
Modify  | 0.12271    | 0.12271    | 0.12271    |   0.0 |  0.16
Other   |            | 0.0108     |            |       |  0.01

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:       540920 ave      540920 max      540920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540920
Ave neighs/atom = 135.23
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.954382748958, Press = -0.746914447697152
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     60000  -17518.045     -17518.045     -17659.351     -17659.351      273.36575      273.36575      44173.647      44173.647     -3625.9213     -3625.9213    
     61000  -17517.875     -17517.875     -17657.907     -17657.907      270.90215      270.90215      44039.998      44039.998      1980.5425      1980.5425    
Loop time of 75.6864 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.142 ns/day, 21.024 hours/ns, 13.212 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    | 75.53      | 75.53      | 75.53      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022526   | 0.022526   | 0.022526   |   0.0 |  0.03
Output  | 5.5474e-05 | 5.5474e-05 | 5.5474e-05 |   0.0 |  0.00
Modify  | 0.12265    | 0.12265    | 0.12265    |   0.0 |  0.16
Other   |            | 0.01098    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6061 ave        6061 max        6061 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540608 ave      540608 max      540608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540608
Ave neighs/atom = 135.152
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.936592544333, Press = -0.549386976920757
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -17517.875     -17517.875     -17657.907     -17657.907      270.90215      270.90215      44039.998      44039.998      1980.5425      1980.5425    
     62000  -17517.868     -17517.868     -17659.883     -17659.883      274.73722      274.73722      44077.739      44077.739      290.77004      290.77004    
Loop time of 75.7063 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.030 hours/ns, 13.209 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    | 75.55      | 75.55      | 75.55      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022633   | 0.022633   | 0.022633   |   0.0 |  0.03
Output  | 5.1537e-05 | 5.1537e-05 | 5.1537e-05 |   0.0 |  0.00
Modify  | 0.12266    | 0.12266    | 0.12266    |   0.0 |  0.16
Other   |            | 0.01086    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6158 ave        6158 max        6158 min
Histogram: 1 0 0 0 0 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 = 272.956022415372, Press = 0.948941828589274
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -17517.868     -17517.868     -17659.883     -17659.883      274.73722      274.73722      44077.739      44077.739      290.77004      290.77004    
     63000  -17513.353     -17513.353     -17653.519     -17653.519      271.16086      271.16086      44130.251      44130.251     -1298.9781     -1298.9781    
Loop time of 75.7282 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.036 hours/ns, 13.205 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    | 75.572     | 75.572     | 75.572     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022632   | 0.022632   | 0.022632   |   0.0 |  0.03
Output  | 5.1777e-05 | 5.1777e-05 | 5.1777e-05 |   0.0 |  0.00
Modify  | 0.12255    | 0.12255    | 0.12255    |   0.0 |  0.16
Other   |            | 0.01105    |            |       |  0.01

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:       541042 ave      541042 max      541042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541042
Ave neighs/atom = 135.2605
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.943669336446, Press = 0.0442337386722067
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -17513.353     -17513.353     -17653.519     -17653.519      271.16086      271.16086      44130.251      44130.251     -1298.9781     -1298.9781    
     64000  -17518.322     -17518.322     -17657.287     -17657.287      268.83798      268.83798      44070.9        44070.9        765.69692      765.69692    
Loop time of 75.838 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.139 ns/day, 21.066 hours/ns, 13.186 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    | 75.682     | 75.682     | 75.682     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022578   | 0.022578   | 0.022578   |   0.0 |  0.03
Output  | 5.36e-05   | 5.36e-05   | 5.36e-05   |   0.0 |  0.00
Modify  | 0.12263    | 0.12263    | 0.12263    |   0.0 |  0.16
Other   |            | 0.01088    |            |       |  0.01

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:       540922 ave      540922 max      540922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540922
Ave neighs/atom = 135.2305
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.935584562288, Press = -0.392944957121367
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -17518.322     -17518.322     -17657.287     -17657.287      268.83798      268.83798      44070.9        44070.9        765.69692      765.69692    
     65000  -17513.791     -17513.791     -17656.624     -17656.624      276.31995      276.31995      44076.873      44076.873      665.71526      665.71526    
Loop time of 75.7261 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.035 hours/ns, 13.205 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    | 75.57      | 75.57      | 75.57      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022655   | 0.022655   | 0.022655   |   0.0 |  0.03
Output  | 7.3368e-05 | 7.3368e-05 | 7.3368e-05 |   0.0 |  0.00
Modify  | 0.1227     | 0.1227     | 0.1227     |   0.0 |  0.16
Other   |            | 0.01102    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6164 ave        6164 max        6164 min
Histogram: 1 0 0 0 0 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 = 272.919285583301, Press = 0.684933417653124
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -17513.791     -17513.791     -17656.624     -17656.624      276.31995      276.31995      44076.873      44076.873      665.71526      665.71526    
     66000  -17521.845     -17521.845     -17659.487     -17659.487      266.27752      266.27752      44136.78       44136.78      -2178.8863     -2178.8863    
Loop time of 75.6233 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.143 ns/day, 21.006 hours/ns, 13.223 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    | 75.467     | 75.467     | 75.467     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022578   | 0.022578   | 0.022578   |   0.0 |  0.03
Output  | 6.4942e-05 | 6.4942e-05 | 6.4942e-05 |   0.0 |  0.00
Modify  | 0.12253    | 0.12253    | 0.12253    |   0.0 |  0.16
Other   |            | 0.01099    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6141 ave        6141 max        6141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541172 ave      541172 max      541172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541172
Ave neighs/atom = 135.293
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.892463099639, Press = 0.151694750496043
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -17521.845     -17521.845     -17659.487     -17659.487      266.27752      266.27752      44136.78       44136.78      -2178.8863     -2178.8863    
     67000  -17515.549     -17515.549     -17657.446     -17657.446      274.51101      274.51101      44062.621      44062.621      1092.6874      1092.6874    
Loop time of 75.6526 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.142 ns/day, 21.015 hours/ns, 13.218 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    | 75.497     | 75.497     | 75.497     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022596   | 0.022596   | 0.022596   |   0.0 |  0.03
Output  | 8.6122e-05 | 8.6122e-05 | 8.6122e-05 |   0.0 |  0.00
Modify  | 0.12254    | 0.12254    | 0.12254    |   0.0 |  0.16
Other   |            | 0.01085    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6138 ave        6138 max        6138 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540724 ave      540724 max      540724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540724
Ave neighs/atom = 135.181
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.886216522423, Press = -0.810294942157873
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -17515.549     -17515.549     -17657.446     -17657.446      274.51101      274.51101      44062.621      44062.621      1092.6874      1092.6874    
     68000  -17517.298     -17517.298     -17657.674     -17657.674      271.56822      271.56822      44050.905      44050.905      1559.2431      1559.2431    
Loop time of 75.5717 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.143 ns/day, 20.992 hours/ns, 13.232 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    | 75.415     | 75.415     | 75.415     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022571   | 0.022571   | 0.022571   |   0.0 |  0.03
Output  | 5.9272e-05 | 5.9272e-05 | 5.9272e-05 |   0.0 |  0.00
Modify  | 0.12265    | 0.12265    | 0.12265    |   0.0 |  0.16
Other   |            | 0.01101    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6143 ave        6143 max        6143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541270 ave      541270 max      541270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541270
Ave neighs/atom = 135.3175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.866476318068, Press = 0.749212560830091
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -17517.298     -17517.298     -17657.674     -17657.674      271.56822      271.56822      44050.905      44050.905      1559.2431      1559.2431    
     69000  -17517.63      -17517.63      -17659.861     -17659.861      275.15531      275.15531      44109.405      44109.405     -1086.3365     -1086.3365    
Loop time of 75.5816 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.143 ns/day, 20.995 hours/ns, 13.231 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    | 75.425     | 75.425     | 75.425     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022756   | 0.022756   | 0.022756   |   0.0 |  0.03
Output  | 6.3439e-05 | 6.3439e-05 | 6.3439e-05 |   0.0 |  0.00
Modify  | 0.12259    | 0.12259    | 0.12259    |   0.0 |  0.16
Other   |            | 0.011      |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6195 ave        6195 max        6195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541270 ave      541270 max      541270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541270
Ave neighs/atom = 135.3175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.885472932816, Press = 0.234565980235585
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -17517.63      -17517.63      -17659.861     -17659.861      275.15531      275.15531      44109.405      44109.405     -1086.3365     -1086.3365    
     70000  -17513.584     -17513.584     -17656.797     -17656.797      277.05472      277.05472      44091.554      44091.554      44.576403      44.576403    
Loop time of 75.6565 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.142 ns/day, 21.016 hours/ns, 13.218 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    | 75.5       | 75.5       | 75.5       |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022485   | 0.022485   | 0.022485   |   0.0 |  0.03
Output  | 6.4421e-05 | 6.4421e-05 | 6.4421e-05 |   0.0 |  0.00
Modify  | 0.12255    | 0.12255    | 0.12255    |   0.0 |  0.16
Other   |            | 0.01106    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6110 ave        6110 max        6110 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541010 ave      541010 max      541010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541010
Ave neighs/atom = 135.2525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.902456339289, Press = -0.11630911120062
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -17513.584     -17513.584     -17656.797     -17656.797      277.05472      277.05472      44091.554      44091.554      44.576403      44.576403    
     71000  -17516.662     -17516.662     -17656.511     -17656.511      270.54786      270.54786      44079.038      44079.038      485.45914      485.45914    
Loop time of 75.6479 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.142 ns/day, 21.013 hours/ns, 13.219 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    | 75.492     | 75.492     | 75.492     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022481   | 0.022481   | 0.022481   |   0.0 |  0.03
Output  | 6.5493e-05 | 6.5493e-05 | 6.5493e-05 |   0.0 |  0.00
Modify  | 0.12255    | 0.12255    | 0.12255    |   0.0 |  0.16
Other   |            | 0.01101    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6141 ave        6141 max        6141 min
Histogram: 1 0 0 0 0 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 = 272.906058958983, Press = 0.377557535824309
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -17516.662     -17516.662     -17656.511     -17656.511      270.54786      270.54786      44079.038      44079.038      485.45914      485.45914    
     72000  -17513.895     -17513.895     -17656.443     -17656.443      275.7676       275.7676       44141.217      44141.217     -2030.9655     -2030.9655    
Loop time of 75.7058 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.141 ns/day, 21.029 hours/ns, 13.209 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    | 75.549     | 75.549     | 75.549     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022627   | 0.022627   | 0.022627   |   0.0 |  0.03
Output  | 6.2718e-05 | 6.2718e-05 | 6.2718e-05 |   0.0 |  0.00
Modify  | 0.12286    | 0.12286    | 0.12286    |   0.0 |  0.16
Other   |            | 0.01105    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6141 ave        6141 max        6141 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541150 ave      541150 max      541150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541150
Ave neighs/atom = 135.2875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.910799572483, Press = 0.168248174444488
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -17513.895     -17513.895     -17656.443     -17656.443      275.7676       275.7676       44141.217      44141.217     -2030.9655     -2030.9655    
     73000  -17514.33      -17514.33      -17654.256     -17654.256      270.69559      270.69559      44074.463      44074.463      868.59851      868.59851    
Loop time of 75.7661 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.140 ns/day, 21.046 hours/ns, 13.199 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    | 75.61      | 75.61      | 75.61      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022478   | 0.022478   | 0.022478   |   0.0 |  0.03
Output  | 6.8238e-05 | 6.8238e-05 | 6.8238e-05 |   0.0 |  0.00
Modify  | 0.1226     | 0.1226     | 0.1226     |   0.0 |  0.16
Other   |            | 0.01103    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6103 ave        6103 max        6103 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540898 ave      540898 max      540898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540898
Ave neighs/atom = 135.2245
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.920830544274, Press = -0.647722593599714
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -17514.33      -17514.33      -17654.256     -17654.256      270.69559      270.69559      44074.463      44074.463      868.59851      868.59851    
     74000  -17517.902     -17517.902     -17657.701     -17657.701      270.45048      270.45048      44054.265      44054.265      1352.9098      1352.9098    
Loop time of 75.5722 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.143 ns/day, 20.992 hours/ns, 13.232 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 75.416     | 75.416     | 75.416     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022556   | 0.022556   | 0.022556   |   0.0 |  0.03
Output  | 6.6956e-05 | 6.6956e-05 | 6.6956e-05 |   0.0 |  0.00
Modify  | 0.12267    | 0.12267    | 0.12267    |   0.0 |  0.16
Other   |            | 0.01098    |            |       |  0.01

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:       541362 ave      541362 max      541362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541362
Ave neighs/atom = 135.3405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.948655022494, Press = 0.631433605467129
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -17517.902     -17517.902     -17657.701     -17657.701      270.45048      270.45048      44054.265      44054.265      1352.9098      1352.9098    
     75000  -17513.652     -17513.652     -17652.812     -17652.812      269.21425      269.21425      44128.7        44128.7       -1242.2878     -1242.2878    
Loop time of 75.6586 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.142 ns/day, 21.016 hours/ns, 13.217 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 75.502     | 75.502     | 75.502     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022783   | 0.022783   | 0.022783   |   0.0 |  0.03
Output  | 7.4129e-05 | 7.4129e-05 | 7.4129e-05 |   0.0 |  0.00
Modify  | 0.12252    | 0.12252    | 0.12252    |   0.0 |  0.16
Other   |            | 0.01087    |            |       |  0.01

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:       541260 ave      541260 max      541260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541260
Ave neighs/atom = 135.315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.956679563519, Press = 0.205961451914548
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -17513.652     -17513.652     -17652.812     -17652.812      269.21425      269.21425      44128.7        44128.7       -1242.2878     -1242.2878    
     76000  -17518.281     -17518.281     -17659.584     -17659.584      273.35923      273.35923      44087.101      44087.101     -112.04022     -112.04022    
Loop time of 75.6353 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.142 ns/day, 21.010 hours/ns, 13.221 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 75.479     | 75.479     | 75.479     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022732   | 0.022732   | 0.022732   |   0.0 |  0.03
Output  | 6.5804e-05 | 6.5804e-05 | 6.5804e-05 |   0.0 |  0.00
Modify  | 0.12252    | 0.12252    | 0.12252    |   0.0 |  0.16
Other   |            | 0.01085    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6165 ave        6165 max        6165 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541160 ave      541160 max      541160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541160
Ave neighs/atom = 135.29
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
44090.4803105758

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0