# 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.521391749382019*${_u_distance}
variable latticeconst_converted equal 3.521391749382019*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52139174938202
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_KimKimJung_2017_NiAlTi__MO_478967255435_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.9614516893    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9614516893/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9614516893/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9614516893/(1*1*${_u_distance})
variable      V0_metal equal 43665.9614516893/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 43665.9614516893*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43665.9614516893 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_478967255435_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.7567      3453.7567    
      1000  -17508.577     -17508.577     -17657.58      -17657.58       288.25501      288.25501      44142.338      44142.338     -1595.3464     -1595.3464    
Loop time of 107.939 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.800 ns/day, 29.983 hours/ns, 9.264 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    | 107.79     | 107.79     | 107.79     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021887   | 0.021887   | 0.021887   |   0.0 |  0.02
Output  | 9.9778e-05 | 9.9778e-05 | 9.9778e-05 |   0.0 |  0.00
Modify  | 0.11998    | 0.11998    | 0.11998    |   0.0 |  0.11
Other   |            | 0.01073    |            |       |  0.01

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.577     -17508.577     -17657.58      -17657.58       288.25501      288.25501      44142.338      44142.338     -1595.3464     -1595.3464    
      2000  -17517.097     -17517.097     -17655.248     -17655.248      267.26217      267.26217      44092.267      44092.267      513.45586      513.45586    
Loop time of 114.419 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.755 ns/day, 31.783 hours/ns, 8.740 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    | 114.26     | 114.26     | 114.26     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022863   | 0.022863   | 0.022863   |   0.0 |  0.02
Output  | 9.3456e-05 | 9.3456e-05 | 9.3456e-05 |   0.0 |  0.00
Modify  | 0.12015    | 0.12015    | 0.12015    |   0.0 |  0.11
Other   |            | 0.01081    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6089 ave        6089 max        6089 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540634 ave      540634 max      540634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540634
Ave neighs/atom = 135.1585
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -17517.097     -17517.097     -17655.248     -17655.248      267.26217      267.26217      44092.267      44092.267      513.45586      513.45586    
      3000  -17516.726     -17516.726     -17657.17      -17657.17       271.69951      271.69951      44091.073      44091.073      359.78553      359.78553    
Loop time of 114.095 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.693 hours/ns, 8.765 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    | 113.94     | 113.94     | 113.94     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022559   | 0.022559   | 0.022559   |   0.0 |  0.02
Output  | 8.1053e-05 | 8.1053e-05 | 8.1053e-05 |   0.0 |  0.00
Modify  | 0.11993    | 0.11993    | 0.11993    |   0.0 |  0.11
Other   |            | 0.01081    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6114 ave        6114 max        6114 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540806 ave      540806 max      540806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540806
Ave neighs/atom = 135.2015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.726     -17516.726     -17657.17      -17657.17       271.69951      271.69951      44091.073      44091.073      359.78553      359.78553    
      4000  -17513.956     -17513.956     -17654.336     -17654.336      271.57441      271.57441      44109.023      44109.023     -41.664841     -41.664841    
Loop time of 114.033 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.676 hours/ns, 8.769 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    | 113.88     | 113.88     | 113.88     |   0.0 | 99.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022673   | 0.022673   | 0.022673   |   0.0 |  0.02
Output  | 7.96e-05   | 7.96e-05   | 7.96e-05   |   0.0 |  0.00
Modify  | 0.11996    | 0.11996    | 0.11996    |   0.0 |  0.11
Other   |            | 0.01082    |            |       |  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:       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 = 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  -17513.956     -17513.956     -17654.336     -17654.336      271.57441      271.57441      44109.023      44109.023     -41.664841     -41.664841    
      5000  -17518.161     -17518.161     -17659.478     -17659.478      273.38583      273.38583      44103.642      44103.642     -295.97815     -295.97815    
Loop time of 114.167 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.713 hours/ns, 8.759 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    | 114.01     | 114.01     | 114.01     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02297    | 0.02297    | 0.02297    |   0.0 |  0.02
Output  | 5.3791e-05 | 5.3791e-05 | 5.3791e-05 |   0.0 |  0.00
Modify  | 0.12065    | 0.12065    | 0.12065    |   0.0 |  0.11
Other   |            | 0.01086    |            |       |  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:       540770 ave      540770 max      540770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540770
Ave neighs/atom = 135.1925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 270.611135334245, Press = -333.668584262518
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.161     -17518.161     -17659.478     -17659.478      273.38583      273.38583      44103.642      44103.642     -295.97815     -295.97815    
      6000  -17512.851     -17512.851     -17654.119     -17654.119      273.29247      273.29247      44060.629      44060.629      2027.4784      2027.4784    
Loop time of 114.231 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.756 ns/day, 31.731 hours/ns, 8.754 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    | 114.07     | 114.07     | 114.07     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022773   | 0.022773   | 0.022773   |   0.0 |  0.02
Output  | 7.0032e-05 | 7.0032e-05 | 7.0032e-05 |   0.0 |  0.00
Modify  | 0.12423    | 0.12423    | 0.12423    |   0.0 |  0.11
Other   |            | 0.01086    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6125 ave        6125 max        6125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540582 ave      540582 max      540582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540582
Ave neighs/atom = 135.1455
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.788199575674, Press = 6.19618528340031
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17512.851     -17512.851     -17654.119     -17654.119      273.29247      273.29247      44060.629      44060.629      2027.4784      2027.4784    
      7000  -17518.113     -17518.113     -17657.601     -17657.601      269.84982      269.84982      44152.994      44152.994     -2174.9728     -2174.9728    
Loop time of 114.128 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.702 hours/ns, 8.762 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    | 113.97     | 113.97     | 113.97     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022863   | 0.022863   | 0.022863   |   0.0 |  0.02
Output  | 6.2076e-05 | 6.2076e-05 | 6.2076e-05 |   0.0 |  0.00
Modify  | 0.12429    | 0.12429    | 0.12429    |   0.0 |  0.11
Other   |            | 0.0109     |            |       |  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:       541102 ave      541102 max      541102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541102
Ave neighs/atom = 135.2755
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.017667503851, Press = 7.42250096509154
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17518.113     -17518.113     -17657.601     -17657.601      269.84982      269.84982      44152.994      44152.994     -2174.9728     -2174.9728    
      8000  -17515.198     -17515.198     -17660.324     -17660.324      280.75567      280.75567      44097.634      44097.634     -104.30545     -104.30545    
Loop time of 114.151 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.709 hours/ns, 8.760 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    | 113.99     | 113.99     | 113.99     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022955   | 0.022955   | 0.022955   |   0.0 |  0.02
Output  | 5.9772e-05 | 5.9772e-05 | 5.9772e-05 |   0.0 |  0.00
Modify  | 0.12409    | 0.12409    | 0.12409    |   0.0 |  0.11
Other   |            | 0.01079    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6080 ave        6080 max        6080 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540444 ave      540444 max      540444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540444
Ave neighs/atom = 135.111
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.964957673212, Press = -22.1650941534657
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.198     -17515.198     -17660.324     -17660.324      280.75567      280.75567      44097.634      44097.634     -104.30545     -104.30545    
      9000  -17519.002     -17519.002     -17659.503     -17659.503      271.80964      271.80964      44081.577      44081.577      584.35231      584.35231    
Loop time of 114.255 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.756 ns/day, 31.738 hours/ns, 8.752 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    | 114.1      | 114.1      | 114.1      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0228     | 0.0228     | 0.0228     |   0.0 |  0.02
Output  | 6.0454e-05 | 6.0454e-05 | 6.0454e-05 |   0.0 |  0.00
Modify  | 0.12418    | 0.12418    | 0.12418    |   0.0 |  0.11
Other   |            | 0.01084    |            |       |  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:       540764 ave      540764 max      540764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540764
Ave neighs/atom = 135.191
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.602527218896, Press = 1.69507270792726
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17519.002     -17519.002     -17659.503     -17659.503      271.80964      271.80964      44081.577      44081.577      584.35231      584.35231    
     10000  -17509.556     -17509.556     -17653.353     -17653.353      278.1835       278.1835       44139.015      44139.015     -1088.1317     -1088.1317    
Loop time of 114.348 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.756 ns/day, 31.763 hours/ns, 8.745 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    | 114.19     | 114.19     | 114.19     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022576   | 0.022576   | 0.022576   |   0.0 |  0.02
Output  | 6.0203e-05 | 6.0203e-05 | 6.0203e-05 |   0.0 |  0.00
Modify  | 0.12432    | 0.12432    | 0.12432    |   0.0 |  0.11
Other   |            | 0.01081    |            |       |  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:       540848 ave      540848 max      540848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540848
Ave neighs/atom = 135.212
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.920792439115, Press = -2.8275517505011
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17509.556     -17509.556     -17653.353     -17653.353      278.1835       278.1835       44139.015      44139.015     -1088.1317     -1088.1317    
     11000  -17517.61      -17517.61      -17654.684     -17654.684      265.17787      265.17787      44083.794      44083.794      858.00671      858.00671    
Loop time of 114.123 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.701 hours/ns, 8.762 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    | 113.97     | 113.97     | 113.97     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022681   | 0.022681   | 0.022681   |   0.0 |  0.02
Output  | 5.8039e-05 | 5.8039e-05 | 5.8039e-05 |   0.0 |  0.00
Modify  | 0.1241     | 0.1241     | 0.1241     |   0.0 |  0.11
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:       540762 ave      540762 max      540762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540762
Ave neighs/atom = 135.1905
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.11136166572, Press = -5.06891784802866
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17517.61      -17517.61      -17654.684     -17654.684      265.17787      265.17787      44083.794      44083.794      858.00671      858.00671    
     12000  -17519.845     -17519.845     -17660.93      -17660.93       272.93851      272.93851      44077.692      44077.692      626.52692      626.52692    
Loop time of 114.128 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.702 hours/ns, 8.762 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    | 113.97     | 113.97     | 113.97     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022798   | 0.022798   | 0.022798   |   0.0 |  0.02
Output  | 6.0744e-05 | 6.0744e-05 | 6.0744e-05 |   0.0 |  0.00
Modify  | 0.12404    | 0.12404    | 0.12404    |   0.0 |  0.11
Other   |            | 0.01081    |            |       |  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:       540924 ave      540924 max      540924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540924
Ave neighs/atom = 135.231
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.170103276252, Press = 6.06944922544436
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17519.845     -17519.845     -17660.93      -17660.93       272.93851      272.93851      44077.692      44077.692      626.52692      626.52692    
     13000  -17515.301     -17515.301     -17658.844     -17658.844      277.69312      277.69312      44168.989      44168.989     -2879.6645     -2879.6645    
Loop time of 114.261 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.756 ns/day, 31.739 hours/ns, 8.752 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    | 114.1      | 114.1      | 114.1      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022964   | 0.022964   | 0.022964   |   0.0 |  0.02
Output  | 5.8019e-05 | 5.8019e-05 | 5.8019e-05 |   0.0 |  0.00
Modify  | 0.12447    | 0.12447    | 0.12447    |   0.0 |  0.11
Other   |            | 0.01088    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6190 ave        6190 max        6190 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540878 ave      540878 max      540878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540878
Ave neighs/atom = 135.2195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.041614262025, Press = -4.17402909333669
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17515.301     -17515.301     -17658.844     -17658.844      277.69312      277.69312      44168.989      44168.989     -2879.6645     -2879.6645    
     14000  -17520.906     -17520.906     -17661.443     -17661.443      271.87877      271.87877      44067.122      44067.122      971.53324      971.53324    
Loop time of 114.12 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.700 hours/ns, 8.763 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    | 113.96     | 113.96     | 113.96     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022656   | 0.022656   | 0.022656   |   0.0 |  0.02
Output  | 0.00011181 | 0.00011181 | 0.00011181 |   0.0 |  0.00
Modify  | 0.12416    | 0.12416    | 0.12416    |   0.0 |  0.11
Other   |            | 0.01083    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6079 ave        6079 max        6079 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540552 ave      540552 max      540552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540552
Ave neighs/atom = 135.138
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.838299550137, Press = -4.43015375885884
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17520.906     -17520.906     -17661.443     -17661.443      271.87877      271.87877      44067.122      44067.122      971.53324      971.53324    
     15000  -17517.759     -17517.759     -17657.375     -17657.375      270.09709      270.09709      44096.813      44096.813      152.43592      152.43592    
Loop time of 114.251 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.756 ns/day, 31.736 hours/ns, 8.753 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    | 114.09     | 114.09     | 114.09     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023011   | 0.023011   | 0.023011   |   0.0 |  0.02
Output  | 5.6466e-05 | 5.6466e-05 | 5.6466e-05 |   0.0 |  0.00
Modify  | 0.12432    | 0.12432    | 0.12432    |   0.0 |  0.11
Other   |            | 0.01089    |            |       |  0.01

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

Total # of neighbors = 540946
Ave neighs/atom = 135.2365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.824871426587, Press = 1.52567150007047
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17517.759     -17517.759     -17657.375     -17657.375      270.09709      270.09709      44096.813      44096.813      152.43592      152.43592    
     16000  -17513.576     -17513.576     -17658.037     -17658.037      279.47029      279.47029      44126.703      44126.703     -1048.9099     -1048.9099    
Loop time of 114.111 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.698 hours/ns, 8.763 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    | 113.95     | 113.95     | 113.95     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022607   | 0.022607   | 0.022607   |   0.0 |  0.02
Output  | 6.1405e-05 | 6.1405e-05 | 6.1405e-05 |   0.0 |  0.00
Modify  | 0.12401    | 0.12401    | 0.12401    |   0.0 |  0.11
Other   |            | 0.01074    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6089 ave        6089 max        6089 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540802 ave      540802 max      540802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540802
Ave neighs/atom = 135.2005
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.766945779081, Press = -2.13061685311003
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17513.576     -17513.576     -17658.037     -17658.037      279.47029      279.47029      44126.703      44126.703     -1048.9099     -1048.9099    
     17000  -17520.547     -17520.547     -17660.342     -17660.342      270.44306      270.44306      44076.829      44076.829      633.0864       633.0864     
Loop time of 114.154 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.710 hours/ns, 8.760 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    | 114        | 114        | 114        |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022852   | 0.022852   | 0.022852   |   0.0 |  0.02
Output  | 6.4051e-05 | 6.4051e-05 | 6.4051e-05 |   0.0 |  0.00
Modify  | 0.12425    | 0.12425    | 0.12425    |   0.0 |  0.11
Other   |            | 0.01087    |            |       |  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:       540746 ave      540746 max      540746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540746
Ave neighs/atom = 135.1865
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.733089367596, Press = -2.64154831110547
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17520.547     -17520.547     -17660.342     -17660.342      270.44306      270.44306      44076.829      44076.829      633.0864       633.0864     
     18000  -17515.04      -17515.04      -17657.616     -17657.616      275.82337      275.82337      44069.313      44069.313      1228.2945      1228.2945    
Loop time of 114.207 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.757 ns/day, 31.724 hours/ns, 8.756 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    | 114.05     | 114.05     | 114.05     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022787   | 0.022787   | 0.022787   |   0.0 |  0.02
Output  | 6.2768e-05 | 6.2768e-05 | 6.2768e-05 |   0.0 |  0.00
Modify  | 0.12417    | 0.12417    | 0.12417    |   0.0 |  0.11
Other   |            | 0.01082    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6100 ave        6100 max        6100 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540770 ave      540770 max      540770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540770
Ave neighs/atom = 135.1925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.665648218714, Press = 3.63724246766346
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     18000  -17515.04      -17515.04      -17657.616     -17657.616      275.82337      275.82337      44069.313      44069.313      1228.2945      1228.2945    
     19000  -17517.961     -17517.961     -17658.624     -17658.624      272.12157      272.12157      44151.997      44151.997     -2275.4194     -2275.4194    
Loop time of 114.032 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.676 hours/ns, 8.769 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    | 113.87     | 113.87     | 113.87     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022878   | 0.022878   | 0.022878   |   0.0 |  0.02
Output  | 6.6595e-05 | 6.6595e-05 | 6.6595e-05 |   0.0 |  0.00
Modify  | 0.12436    | 0.12436    | 0.12436    |   0.0 |  0.11
Other   |            | 0.0109     |            |       |  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:       541026 ave      541026 max      541026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.759 ns/day, 31.605 hours/ns, 8.789 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    | 113.62     | 113.62     | 113.62     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022519   | 0.022519   | 0.022519   |   0.0 |  0.02
Output  | 7.5552e-05 | 7.5552e-05 | 7.5552e-05 |   0.0 |  0.00
Modify  | 0.12419    | 0.12419    | 0.12419    |   0.0 |  0.11
Other   |            | 0.01082    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6038 ave        6038 max        6038 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540550 ave      540550 max      540550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540550
Ave neighs/atom = 135.1375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.61486320898, Press = -1.78343652664321
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     20000  -17516.166     -17516.166     -17656.372     -17656.372      271.23784      271.23784      44070.347      44070.347      1353.9449      1353.9449    
     21000  -17518.719     -17518.719     -17661.095     -17661.095      275.4353       275.4353       44104.697      44104.697     -531.89243     -531.89243    
Loop time of 113.908 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.759 ns/day, 31.641 hours/ns, 8.779 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    | 113.75     | 113.75     | 113.75     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023025   | 0.023025   | 0.023025   |   0.0 |  0.02
Output  | 6.4571e-05 | 6.4571e-05 | 6.4571e-05 |   0.0 |  0.00
Modify  | 0.12464    | 0.12464    | 0.12464    |   0.0 |  0.11
Other   |            | 0.01095    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6202 ave        6202 max        6202 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540988 ave      540988 max      540988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

Performance: 0.756 ns/day, 31.736 hours/ns, 8.753 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    | 114.09     | 114.09     | 114.09     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022836   | 0.022836   | 0.022836   |   0.0 |  0.02
Output  | 5.7258e-05 | 5.7258e-05 | 5.7258e-05 |   0.0 |  0.00
Modify  | 0.12471    | 0.12471    | 0.12471    |   0.0 |  0.11
Other   |            | 0.01086    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6071 ave        6071 max        6071 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540816 ave      540816 max      540816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540816
Ave neighs/atom = 135.204
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.53470277471, Press = -1.74522226902288
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     22000  -17517.254     -17517.254     -17658.548     -17658.548      273.34239      273.34239      44119.353      44119.353     -897.16044     -897.16044    
     23000  -17511.733     -17511.733     -17655.526     -17655.526      278.17767      278.17767      44100.024      44100.024      259.08436      259.08436    
Loop time of 114.319 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.756 ns/day, 31.755 hours/ns, 8.747 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    | 114.16     | 114.16     | 114.16     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022766   | 0.022766   | 0.022766   |   0.0 |  0.02
Output  | 5.7588e-05 | 5.7588e-05 | 5.7588e-05 |   0.0 |  0.00
Modify  | 0.12412    | 0.12412    | 0.12412    |   0.0 |  0.11
Other   |            | 0.01093    |            |       |  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:       540822 ave      540822 max      540822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540822
Ave neighs/atom = 135.2055
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.629656988329, Press = -0.238741933138702
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     23000  -17511.733     -17511.733     -17655.526     -17655.526      278.17767      278.17767      44100.024      44100.024      259.08436      259.08436    
     24000  -17518.9       -17518.9       -17659.392     -17659.392      271.79135      271.79135      44102.634      44102.634     -346.6557      -346.6557     
Loop time of 114.229 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.756 ns/day, 31.730 hours/ns, 8.754 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    | 114.07     | 114.07     | 114.07     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022569   | 0.022569   | 0.022569   |   0.0 |  0.02
Output  | 4.9422e-05 | 4.9422e-05 | 4.9422e-05 |   0.0 |  0.00
Modify  | 0.12439    | 0.12439    | 0.12439    |   0.0 |  0.11
Other   |            | 0.0108     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6083 ave        6083 max        6083 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540926 ave      540926 max      540926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540926
Ave neighs/atom = 135.2315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.68749375994, Press = -0.540372548964852
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     24000  -17518.9       -17518.9       -17659.392     -17659.392      271.79135      271.79135      44102.634      44102.634     -346.6557      -346.6557     
     25000  -17514.472     -17514.472     -17655.581     -17655.581      272.98371      272.98371      44106.612      44106.612     -93.928006     -93.928006    
Loop time of 113.934 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.648 hours/ns, 8.777 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    | 113.78     | 113.78     | 113.78     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0227     | 0.0227     | 0.0227     |   0.0 |  0.02
Output  | 4.5035e-05 | 4.5035e-05 | 4.5035e-05 |   0.0 |  0.00
Modify  | 0.1243     | 0.1243     | 0.1243     |   0.0 |  0.11
Other   |            | 0.01087    |            |       |  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:       540808 ave      540808 max      540808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540808
Ave neighs/atom = 135.202
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.719599028745, Press = -0.661123166121077
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     25000  -17514.472     -17514.472     -17655.581     -17655.581      272.98371      272.98371      44106.612      44106.612     -93.928006     -93.928006    
     26000  -17518.609     -17518.609     -17656.216     -17656.216      266.20843      266.20843      44093.427      44093.427      337.3813       337.3813     
Loop time of 113.957 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.655 hours/ns, 8.775 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    | 113.8      | 113.8      | 113.8      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022783   | 0.022783   | 0.022783   |   0.0 |  0.02
Output  | 5.7628e-05 | 5.7628e-05 | 5.7628e-05 |   0.0 |  0.00
Modify  | 0.12406    | 0.12406    | 0.12406    |   0.0 |  0.11
Other   |            | 0.0108     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6117 ave        6117 max        6117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540782 ave      540782 max      540782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540782
Ave neighs/atom = 135.1955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.661112560079, Press = -1.00964121441392
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     26000  -17518.609     -17518.609     -17656.216     -17656.216      266.20843      266.20843      44093.427      44093.427      337.3813       337.3813     
     27000  -17517.767     -17517.767     -17659.359     -17659.359      273.92063      273.92063      44100.282      44100.282     -248.81096     -248.81096    
Loop time of 113.646 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.760 ns/day, 31.568 hours/ns, 8.799 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    | 113.49     | 113.49     | 113.49     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02275    | 0.02275    | 0.02275    |   0.0 |  0.02
Output  | 5.1186e-05 | 5.1186e-05 | 5.1186e-05 |   0.0 |  0.00
Modify  | 0.1238     | 0.1238     | 0.1238     |   0.0 |  0.11
Other   |            | 0.01084    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6102 ave        6102 max        6102 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540824 ave      540824 max      540824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540824
Ave neighs/atom = 135.206
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.658940227695, Press = -0.457999747964
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     27000  -17517.767     -17517.767     -17659.359     -17659.359      273.92063      273.92063      44100.282      44100.282     -248.81096     -248.81096    
     28000  -17515.175     -17515.175     -17656.47      -17656.47       273.34471      273.34471      44106.339      44106.339     -177.83945     -177.83945    
Loop time of 113.877 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.759 ns/day, 31.632 hours/ns, 8.781 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    | 113.72     | 113.72     | 113.72     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022742   | 0.022742   | 0.022742   |   0.0 |  0.02
Output  | 5.9031e-05 | 5.9031e-05 | 5.9031e-05 |   0.0 |  0.00
Modify  | 0.12399    | 0.12399    | 0.12399    |   0.0 |  0.11
Other   |            | 0.01085    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6107 ave        6107 max        6107 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540778 ave      540778 max      540778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540778
Ave neighs/atom = 135.1945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.667611633402, Press = -1.41299539791327
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     28000  -17515.175     -17515.175     -17656.47      -17656.47       273.34471      273.34471      44106.339      44106.339     -177.83945     -177.83945    
     29000  -17516.525     -17516.525     -17656.026     -17656.026      269.87486      269.87486      44068.266      44068.266      1449.9853      1449.9853    
Loop time of 114.01 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.669 hours/ns, 8.771 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    | 113.85     | 113.85     | 113.85     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02272    | 0.02272    | 0.02272    |   0.0 |  0.02
Output  | 5.0835e-05 | 5.0835e-05 | 5.0835e-05 |   0.0 |  0.00
Modify  | 0.12377    | 0.12377    | 0.12377    |   0.0 |  0.11
Other   |            | 0.01076    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6120 ave        6120 max        6120 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540778 ave      540778 max      540778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540778
Ave neighs/atom = 135.1945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.726232793455, Press = -0.491508342217101
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     29000  -17516.525     -17516.525     -17656.026     -17656.026      269.87486      269.87486      44068.266      44068.266      1449.9853      1449.9853    
     30000  -17512.372     -17512.372     -17654.876     -17654.876      275.68348      275.68348      44130.443      44130.443     -1006.6328     -1006.6328    
Loop time of 113.92 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.758 ns/day, 31.644 hours/ns, 8.778 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    | 113.76     | 113.76     | 113.76     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022662   | 0.022662   | 0.022662   |   0.0 |  0.02
Output  | 5.1577e-05 | 5.1577e-05 | 5.1577e-05 |   0.0 |  0.00
Modify  | 0.12382    | 0.12382    | 0.12382    |   0.0 |  0.11
Other   |            | 0.0108     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6118 ave        6118 max        6118 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540862 ave      540862 max      540862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540862
Ave neighs/atom = 135.2155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.786567107199, Press = 0.772207173526904
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     30000  -17512.372     -17512.372     -17654.876     -17654.876      275.68348      275.68348      44130.443      44130.443     -1006.6328     -1006.6328    
     31000  -17514.789     -17514.789     -17655.843     -17655.843      272.87734      272.87734      44114.113      44114.113     -435.90887     -435.90887    
Loop time of 113.864 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.759 ns/day, 31.629 hours/ns, 8.782 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    | 113.71     | 113.71     | 113.71     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022758   | 0.022758   | 0.022758   |   0.0 |  0.02
Output  | 4.8872e-05 | 4.8872e-05 | 4.8872e-05 |   0.0 |  0.00
Modify  | 0.12406    | 0.12406    | 0.12406    |   0.0 |  0.11
Other   |            | 0.01082    |            |       |  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:       540636 ave      540636 max      540636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540636
Ave neighs/atom = 135.159
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.846544909142, Press = -2.68044680886485
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     31000  -17514.789     -17514.789     -17655.843     -17655.843      272.87734      272.87734      44114.113      44114.113     -435.90887     -435.90887    
     32000  -17518.841     -17518.841     -17659.069     -17659.069      271.28219      271.28219      44054.973      44054.973      1604.8392      1604.8392    
Loop time of 114.361 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.756 ns/day, 31.767 hours/ns, 8.744 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    | 114.2      | 114.2      | 114.2      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022876   | 0.022876   | 0.022876   |   0.0 |  0.02
Output  | 4.8722e-05 | 4.8722e-05 | 4.8722e-05 |   0.0 |  0.00
Modify  | 0.12452    | 0.12452    | 0.12452    |   0.0 |  0.11
Other   |            | 0.01084    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6099 ave        6099 max        6099 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540714 ave      540714 max      540714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540714
Ave neighs/atom = 135.1785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.812649083559, Press = 0.245358293206385
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     32000  -17518.841     -17518.841     -17659.069     -17659.069      271.28219      271.28219      44054.973      44054.973      1604.8392      1604.8392    
     33000  -17513.713     -17513.713     -17655.906     -17655.906      275.08187      275.08187      44123.291      44123.291     -831.51143     -831.51143    
Loop time of 114.475 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.755 ns/day, 31.799 hours/ns, 8.736 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    | 114.32     | 114.32     | 114.32     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022881   | 0.022881   | 0.022881   |   0.0 |  0.02
Output  | 4.8191e-05 | 4.8191e-05 | 4.8191e-05 |   0.0 |  0.00
Modify  | 0.12458    | 0.12458    | 0.12458    |   0.0 |  0.11
Other   |            | 0.01088    |            |       |  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:       540948 ave      540948 max      540948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540948
Ave neighs/atom = 135.237
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.79742663428, Press = -0.292518019044816
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     33000  -17513.713     -17513.713     -17655.906     -17655.906      275.08187      275.08187      44123.291      44123.291     -831.51143     -831.51143    
     34000  -17517.729     -17517.729     -17657.195     -17657.195      269.80636      269.80636      44095.121      44095.121      217.66489      217.66489    
Loop time of 114.738 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.872 hours/ns, 8.716 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    | 114.58     | 114.58     | 114.58     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023053   | 0.023053   | 0.023053   |   0.0 |  0.02
Output  | 4.741e-05  | 4.741e-05  | 4.741e-05  |   0.0 |  0.00
Modify  | 0.12498    | 0.12498    | 0.12498    |   0.0 |  0.11
Other   |            | 0.01094    |            |       |  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:       540794 ave      540794 max      540794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540794
Ave neighs/atom = 135.1985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.78833484646, Press = -0.932544774263144
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     34000  -17517.729     -17517.729     -17657.195     -17657.195      269.80636      269.80636      44095.121      44095.121      217.66489      217.66489    
     35000  -17515.84      -17515.84      -17656.2       -17656.2        271.53592      271.53592      44092.77       44092.77       392.51335      392.51335    
Loop time of 115.406 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.749 ns/day, 32.057 hours/ns, 8.665 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    | 115.25     | 115.25     | 115.25     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02333    | 0.02333    | 0.02333    |   0.0 |  0.02
Output  | 4.4965e-05 | 4.4965e-05 | 4.4965e-05 |   0.0 |  0.00
Modify  | 0.12605    | 0.12605    | 0.12605    |   0.0 |  0.11
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:       540764 ave      540764 max      540764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540764
Ave neighs/atom = 135.191
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.80190721307, Press = -0.101857185968058
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     35000  -17515.84      -17515.84      -17656.2       -17656.2        271.53592      271.53592      44092.77       44092.77       392.51335      392.51335    
     36000  -17514.287     -17514.287     -17656.469     -17656.469      275.06114      275.06114      44134.59       44134.59      -1268.5533     -1268.5533    
Loop time of 115.093 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.751 ns/day, 31.970 hours/ns, 8.689 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    | 114.93     | 114.93     | 114.93     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023058   | 0.023058   | 0.023058   |   0.0 |  0.02
Output  | 4.9994e-05 | 4.9994e-05 | 4.9994e-05 |   0.0 |  0.00
Modify  | 0.12562    | 0.12562    | 0.12562    |   0.0 |  0.11
Other   |            | 0.01087    |            |       |  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:       540854 ave      540854 max      540854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540854
Ave neighs/atom = 135.2135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.787529711552, Press = -0.914405664252664
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     36000  -17514.287     -17514.287     -17656.469     -17656.469      275.06114      275.06114      44134.59       44134.59      -1268.5533     -1268.5533    
     37000  -17519.76      -17519.76      -17659.318     -17659.318      269.98466      269.98466      44048.333      44048.333      1972.9986      1972.9986    
Loop time of 115.322 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.749 ns/day, 32.034 hours/ns, 8.671 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    | 115.16     | 115.16     | 115.16     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023059   | 0.023059   | 0.023059   |   0.0 |  0.02
Output  | 6.0042e-05 | 6.0042e-05 | 6.0042e-05 |   0.0 |  0.00
Modify  | 0.12567    | 0.12567    | 0.12567    |   0.0 |  0.11
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:       540630 ave      540630 max      540630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540630
Ave neighs/atom = 135.1575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.770946636708, Press = -1.68910625904569
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     37000  -17519.76      -17519.76      -17659.318     -17659.318      269.98466      269.98466      44048.333      44048.333      1972.9986      1972.9986    
     38000  -17516.433     -17516.433     -17657.598     -17657.598      273.09386      273.09386      44100.073      44100.073     -36.394243     -36.394243    
Loop time of 115.455 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.748 ns/day, 32.071 hours/ns, 8.661 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    | 115.3      | 115.3      | 115.3      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022723   | 0.022723   | 0.022723   |   0.0 |  0.02
Output  | 5.4773e-05 | 5.4773e-05 | 5.4773e-05 |   0.0 |  0.00
Modify  | 0.12531    | 0.12531    | 0.12531    |   0.0 |  0.11
Other   |            | 0.01087    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6084 ave        6084 max        6084 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540822 ave      540822 max      540822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540822
Ave neighs/atom = 135.2055
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.729876406182, Press = 1.24241389094359
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     38000  -17516.433     -17516.433     -17657.598     -17657.598      273.09386      273.09386      44100.073      44100.073     -36.394243     -36.394243    
     39000  -17518.06      -17518.06      -17657.341     -17657.341      269.4497       269.4497       44125.894      44125.894     -1055.392      -1055.392     
Loop time of 115.452 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.748 ns/day, 32.070 hours/ns, 8.662 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    | 115.29     | 115.29     | 115.29     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023036   | 0.023036   | 0.023036   |   0.0 |  0.02
Output  | 4.9332e-05 | 4.9332e-05 | 4.9332e-05 |   0.0 |  0.00
Modify  | 0.12576    | 0.12576    | 0.12576    |   0.0 |  0.11
Other   |            | 0.01099    |            |       |  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:       540866 ave      540866 max      540866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540866
Ave neighs/atom = 135.2165
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.73275441015, Press = -1.31064836888185
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     39000  -17518.06      -17518.06      -17657.341     -17657.341      269.4497       269.4497       44125.894      44125.894     -1055.392      -1055.392     
     40000  -17512.917     -17512.917     -17655.68      -17655.68       276.18559      276.18559      44076.973      44076.973      1154.839       1154.839     
Loop time of 115.458 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.748 ns/day, 32.072 hours/ns, 8.661 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    | 115.3      | 115.3      | 115.3      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023238   | 0.023238   | 0.023238   |   0.0 |  0.02
Output  | 5.6536e-05 | 5.6536e-05 | 5.6536e-05 |   0.0 |  0.00
Modify  | 0.12533    | 0.12533    | 0.12533    |   0.0 |  0.11
Other   |            | 0.01091    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6108 ave        6108 max        6108 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540674 ave      540674 max      540674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540674
Ave neighs/atom = 135.1685
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.697312059401, Press = -0.912482328921328
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     40000  -17512.917     -17512.917     -17655.68      -17655.68       276.18559      276.18559      44076.973      44076.973      1154.839       1154.839     
     41000  -17516.569     -17516.569     -17655.583     -17655.583      268.93368      268.93368      44098.505      44098.505      221.78218      221.78218    
Loop time of 115.606 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.747 ns/day, 32.113 hours/ns, 8.650 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    | 115.45     | 115.45     | 115.45     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023084   | 0.023084   | 0.023084   |   0.0 |  0.02
Output  | 4.7149e-05 | 4.7149e-05 | 4.7149e-05 |   0.0 |  0.00
Modify  | 0.1252     | 0.1252     | 0.1252     |   0.0 |  0.11
Other   |            | 0.01093    |            |       |  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:       540878 ave      540878 max      540878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540878
Ave neighs/atom = 135.2195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.710656225085, Press = 0.332219404430422
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     41000  -17516.569     -17516.569     -17655.583     -17655.583      268.93368      268.93368      44098.505      44098.505      221.78218      221.78218    
     42000  -17513.509     -17513.509     -17654.147     -17654.147      272.0749       272.0749       44113.207      44113.207     -279.34885     -279.34885    
Loop time of 115.173 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.750 ns/day, 31.993 hours/ns, 8.683 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    | 115.01     | 115.01     | 115.01     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022903   | 0.022903   | 0.022903   |   0.0 |  0.02
Output  | 4.5656e-05 | 4.5656e-05 | 4.5656e-05 |   0.0 |  0.00
Modify  | 0.12541    | 0.12541    | 0.12541    |   0.0 |  0.11
Other   |            | 0.01087    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6091 ave        6091 max        6091 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540802 ave      540802 max      540802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540802
Ave neighs/atom = 135.2005
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.729059735335, Press = -0.614061256981007
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     42000  -17513.509     -17513.509     -17654.147     -17654.147      272.0749       272.0749       44113.207      44113.207     -279.34885     -279.34885    
     43000  -17515.922     -17515.922     -17655.432     -17655.432      269.89164      269.89164      44098.316      44098.316      175.78725      175.78725    
Loop time of 115.316 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.749 ns/day, 32.032 hours/ns, 8.672 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    | 115.16     | 115.16     | 115.16     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023229   | 0.023229   | 0.023229   |   0.0 |  0.02
Output  | 5.5234e-05 | 5.5234e-05 | 5.5234e-05 |   0.0 |  0.00
Modify  | 0.12562    | 0.12562    | 0.12562    |   0.0 |  0.11
Other   |            | 0.01096    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6140 ave        6140 max        6140 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540880 ave      540880 max      540880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540880
Ave neighs/atom = 135.22
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.730402845319, Press = -0.61570618672542
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17515.922     -17515.922     -17655.432     -17655.432      269.89164      269.89164      44098.316      44098.316      175.78725      175.78725    
     44000  -17511.357     -17511.357     -17653.814     -17653.814      275.59309      275.59309      44105.886      44105.886      144.69178      144.69178    
Loop time of 115.274 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.750 ns/day, 32.020 hours/ns, 8.675 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    | 115.11     | 115.11     | 115.11     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02298    | 0.02298    | 0.02298    |   0.0 |  0.02
Output  | 4.5275e-05 | 4.5275e-05 | 4.5275e-05 |   0.0 |  0.00
Modify  | 0.12554    | 0.12554    | 0.12554    |   0.0 |  0.11
Other   |            | 0.01093    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6117 ave        6117 max        6117 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540854 ave      540854 max      540854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540854
Ave neighs/atom = 135.2135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.778029997518, Press = -0.364036582541001
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17511.357     -17511.357     -17653.814     -17653.814      275.59309      275.59309      44105.886      44105.886      144.69178      144.69178    
     45000  -17513.924     -17513.924     -17655.076     -17655.076      273.0687       273.0687       44105.077      44105.077      87.701015      87.701015    
Loop time of 115.116 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.751 ns/day, 31.977 hours/ns, 8.687 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    | 114.96     | 114.96     | 114.96     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023173   | 0.023173   | 0.023173   |   0.0 |  0.02
Output  | 0.00010536 | 0.00010536 | 0.00010536 |   0.0 |  0.00
Modify  | 0.1245     | 0.1245     | 0.1245     |   0.0 |  0.11
Other   |            | 0.01074    |            |       |  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:       540780 ave      540780 max      540780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540780
Ave neighs/atom = 135.195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.804474311114, Press = -1.0560552277394
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17513.924     -17513.924     -17655.076     -17655.076      273.0687       273.0687       44105.077      44105.077      87.701015      87.701015    
     46000  -17517.356     -17517.356     -17656.239     -17656.239      268.67997      268.67997      44074.681      44074.681      1100.4224      1100.4224    
Loop time of 114.67 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.853 hours/ns, 8.721 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    | 114.51     | 114.51     | 114.51     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022919   | 0.022919   | 0.022919   |   0.0 |  0.02
Output  | 5.1226e-05 | 5.1226e-05 | 5.1226e-05 |   0.0 |  0.00
Modify  | 0.12361    | 0.12361    | 0.12361    |   0.0 |  0.11
Other   |            | 0.01061    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6091 ave        6091 max        6091 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540624 ave      540624 max      540624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540624
Ave neighs/atom = 135.156
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.821240244853, Press = -0.241170824326575
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.356     -17517.356     -17656.239     -17656.239      268.67997      268.67997      44074.681      44074.681      1100.4224      1100.4224    
     47000  -17515.408     -17515.408     -17655.147     -17655.147      270.33446      270.33446      44139.596      44139.596     -1470.6359     -1470.6359    
Loop time of 114.863 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.752 ns/day, 31.907 hours/ns, 8.706 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    | 114.71     | 114.71     | 114.71     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022899   | 0.022899   | 0.022899   |   0.0 |  0.02
Output  | 4.4263e-05 | 4.4263e-05 | 4.4263e-05 |   0.0 |  0.00
Modify  | 0.12346    | 0.12346    | 0.12346    |   0.0 |  0.11
Other   |            | 0.01058    |            |       |  0.01

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

Total # of neighbors = 540914
Ave neighs/atom = 135.2285
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.785752694488, Press = 0.0080224212002723
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17515.408     -17515.408     -17655.147     -17655.147      270.33446      270.33446      44139.596      44139.596     -1470.6359     -1470.6359    
     48000  -17517.368     -17517.368     -17660.13      -17660.13       276.18386      276.18386      44091.697      44091.697      29.225165      29.225165    
Loop time of 114.488 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.755 ns/day, 31.802 hours/ns, 8.735 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    | 114.33     | 114.33     | 114.33     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022957   | 0.022957   | 0.022957   |   0.0 |  0.02
Output  | 6.7066e-05 | 6.7066e-05 | 6.7066e-05 |   0.0 |  0.00
Modify  | 0.12331    | 0.12331    | 0.12331    |   0.0 |  0.11
Other   |            | 0.01061    |            |       |  0.01

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

Total # of neighbors = 540736
Ave neighs/atom = 135.184
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.824742088608, Press = -2.11149367623434
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17517.368     -17517.368     -17660.13      -17660.13       276.18386      276.18386      44091.697      44091.697      29.225165      29.225165    
     49000  -17515.092     -17515.092     -17656.943     -17656.943      274.42129      274.42129      44071.699      44071.699      1238.895       1238.895     
Loop time of 114.594 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.754 ns/day, 31.832 hours/ns, 8.726 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    | 114.44     | 114.44     | 114.44     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022947   | 0.022947   | 0.022947   |   0.0 |  0.02
Output  | 5.5014e-05 | 5.5014e-05 | 5.5014e-05 |   0.0 |  0.00
Modify  | 0.12333    | 0.12333    | 0.12333    |   0.0 |  0.11
Other   |            | 0.0106     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6087 ave        6087 max        6087 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540842 ave      540842 max      540842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540842
Ave neighs/atom = 135.2105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.830968723096, Press = 0.0414525691530895
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     49000  -17515.092     -17515.092     -17656.943     -17656.943      274.42129      274.42129      44071.699      44071.699      1238.895       1238.895     
     50000  -17516.031     -17516.031     -17656.41      -17656.41       271.57151      271.57151      44111.303      44111.303     -401.60723     -401.60723    
Loop time of 114.635 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.754 ns/day, 31.843 hours/ns, 8.723 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    | 114.48     | 114.48     | 114.48     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023148   | 0.023148   | 0.023148   |   0.0 |  0.02
Output  | 5.1326e-05 | 5.1326e-05 | 5.1326e-05 |   0.0 |  0.00
Modify  | 0.12355    | 0.12355    | 0.12355    |   0.0 |  0.11
Other   |            | 0.01064    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6125 ave        6125 max        6125 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540824 ave      540824 max      540824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540824
Ave neighs/atom = 135.206
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.797955482414, Press = -0.462445174836859
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17516.031     -17516.031     -17656.41      -17656.41       271.57151      271.57151      44111.303      44111.303     -401.60723     -401.60723    
     51000  -17519.594     -17519.594     -17661.428     -17661.428      274.38635      274.38635      44084.2        44084.2        255.8703       255.8703     
Loop time of 114.788 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.886 hours/ns, 8.712 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    | 114.63     | 114.63     | 114.63     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022907   | 0.022907   | 0.022907   |   0.0 |  0.02
Output  | 6.2176e-05 | 6.2176e-05 | 6.2176e-05 |   0.0 |  0.00
Modify  | 0.12379    | 0.12379    | 0.12379    |   0.0 |  0.11
Other   |            | 0.01064    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6081 ave        6081 max        6081 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540770 ave      540770 max      540770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540770
Ave neighs/atom = 135.1925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.79064878889, Press = -0.712500298084858
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     51000  -17519.594     -17519.594     -17661.428     -17661.428      274.38635      274.38635      44084.2        44084.2        255.8703       255.8703     
     52000  -17514.442     -17514.442     -17655.983     -17655.983      273.82154      273.82154      44101.05       44101.05       69.948022      69.948022    
Loop time of 114.818 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.752 ns/day, 31.894 hours/ns, 8.709 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    | 114.66     | 114.66     | 114.66     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022788   | 0.022788   | 0.022788   |   0.0 |  0.02
Output  | 5.358e-05  | 5.358e-05  | 5.358e-05  |   0.0 |  0.00
Modify  | 0.12353    | 0.12353    | 0.12353    |   0.0 |  0.11
Other   |            | 0.01061    |            |       |  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:       540792 ave      540792 max      540792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540792
Ave neighs/atom = 135.198
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.802917540997, Press = 0.00926263268577703
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17514.442     -17514.442     -17655.983     -17655.983      273.82154      273.82154      44101.05       44101.05       69.948022      69.948022    
     53000  -17516.442     -17516.442     -17657.96      -17657.96       273.77486      273.77486      44130.145      44130.145     -1341.1385     -1341.1385    
Loop time of 114.928 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.752 ns/day, 31.924 hours/ns, 8.701 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    | 114.77     | 114.77     | 114.77     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022893   | 0.022893   | 0.022893   |   0.0 |  0.02
Output  | 5.3952e-05 | 5.3952e-05 | 5.3952e-05 |   0.0 |  0.00
Modify  | 0.12327    | 0.12327    | 0.12327    |   0.0 |  0.11
Other   |            | 0.01058    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6090 ave        6090 max        6090 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540738 ave      540738 max      540738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540738
Ave neighs/atom = 135.1845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.814470638672, Press = -1.01607772364321
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17516.442     -17516.442     -17657.96      -17657.96       273.77486      273.77486      44130.145      44130.145     -1341.1385     -1341.1385    
     54000  -17514.29      -17514.29      -17657.594     -17657.594      277.23313      277.23313      44063.094      44063.094      1596.7483      1596.7483    
Loop time of 114.915 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.752 ns/day, 31.921 hours/ns, 8.702 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    | 114.76     | 114.76     | 114.76     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022813   | 0.022813   | 0.022813   |   0.0 |  0.02
Output  | 5.284e-05  | 5.284e-05  | 5.284e-05  |   0.0 |  0.00
Modify  | 0.12331    | 0.12331    | 0.12331    |   0.0 |  0.11
Other   |            | 0.01063    |            |       |  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:       540690 ave      540690 max      540690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540690
Ave neighs/atom = 135.1725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.821082509207, Press = -0.645340787999654
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17514.29      -17514.29      -17657.594     -17657.594      277.23313      277.23313      44063.094      44063.094      1596.7483      1596.7483    
     55000  -17520.555     -17520.555     -17659.399     -17659.399      268.60313      268.60313      44114.908      44114.908     -857.68553     -857.68553    
Loop time of 114.79 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.886 hours/ns, 8.712 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    | 114.63     | 114.63     | 114.63     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023116   | 0.023116   | 0.023116   |   0.0 |  0.02
Output  | 5.313e-05  | 5.313e-05  | 5.313e-05  |   0.0 |  0.00
Modify  | 0.12366    | 0.12366    | 0.12366    |   0.0 |  0.11
Other   |            | 0.01064    |            |       |  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:       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.80186290787, Press = 0.357954728322062
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     55000  -17520.555     -17520.555     -17659.399     -17659.399      268.60313      268.60313      44114.908      44114.908     -857.68553     -857.68553    
     56000  -17516.804     -17516.804     -17657.436     -17657.436      272.06288      272.06288      44114.419      44114.419     -587.66758     -587.66758    
Loop time of 115.143 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.750 ns/day, 31.984 hours/ns, 8.685 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    | 114.99     | 114.99     | 114.99     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022953   | 0.022953   | 0.022953   |   0.0 |  0.02
Output  | 4.8732e-05 | 4.8732e-05 | 4.8732e-05 |   0.0 |  0.00
Modify  | 0.12379    | 0.12379    | 0.12379    |   0.0 |  0.11
Other   |            | 0.01064    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6066 ave        6066 max        6066 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540562 ave      540562 max      540562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540562
Ave neighs/atom = 135.1405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.807536085134, Press = -1.4064467999043
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17516.804     -17516.804     -17657.436     -17657.436      272.06288      272.06288      44114.419      44114.419     -587.66758     -587.66758    
     57000  -17519.103     -17519.103     -17659.848     -17659.848      272.28153      272.28153      44065.594      44065.594      1206.4477      1206.4477    
Loop time of 114.967 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.752 ns/day, 31.935 hours/ns, 8.698 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    | 114.81     | 114.81     | 114.81     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022954   | 0.022954   | 0.022954   |   0.0 |  0.02
Output  | 4.8041e-05 | 4.8041e-05 | 4.8041e-05 |   0.0 |  0.00
Modify  | 0.12315    | 0.12315    | 0.12315    |   0.0 |  0.11
Other   |            | 0.01061    |            |       |  0.01

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

Total # of neighbors = 540680
Ave neighs/atom = 135.17
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.807824611973, Press = -0.309298320505333
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17519.103     -17519.103     -17659.848     -17659.848      272.28153      272.28153      44065.594      44065.594      1206.4477      1206.4477    
     58000  -17510.898     -17510.898     -17655.255     -17655.255      279.26947      279.26947      44121.17       44121.17      -583.3662      -583.3662     
Loop time of 114.712 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.864 hours/ns, 8.717 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    | 114.56     | 114.56     | 114.56     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022879   | 0.022879   | 0.022879   |   0.0 |  0.02
Output  | 4.5636e-05 | 4.5636e-05 | 4.5636e-05 |   0.0 |  0.00
Modify  | 0.12344    | 0.12344    | 0.12344    |   0.0 |  0.11
Other   |            | 0.01061    |            |       |  0.01

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

Total # of neighbors = 540794
Ave neighs/atom = 135.1985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.820669033671, Press = -0.205811948042359
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17510.898     -17510.898     -17655.255     -17655.255      279.26947      279.26947      44121.17       44121.17      -583.3662      -583.3662     
     59000  -17517.701     -17517.701     -17659.042     -17659.042      273.43372      273.43372      44101.254      44101.254     -213.51927     -213.51927    
Loop time of 114.885 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.752 ns/day, 31.912 hours/ns, 8.704 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    | 114.73     | 114.73     | 114.73     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022942   | 0.022942   | 0.022942   |   0.0 |  0.02
Output  | 5.4442e-05 | 5.4442e-05 | 5.4442e-05 |   0.0 |  0.00
Modify  | 0.12324    | 0.12324    | 0.12324    |   0.0 |  0.11
Other   |            | 0.01066    |            |       |  0.01

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

Total # of neighbors = 540768
Ave neighs/atom = 135.192
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.851867325755, Press = -0.682807164214076
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17517.701     -17517.701     -17659.042     -17659.042      273.43372      273.43372      44101.254      44101.254     -213.51927     -213.51927    
     60000  -17516.773     -17516.773     -17656.262     -17656.262      269.8498       269.8498       44088.61       44088.61       555.4125       555.4125     
Loop time of 115.084 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.751 ns/day, 31.968 hours/ns, 8.689 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    | 114.93     | 114.93     | 114.93     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022903   | 0.022903   | 0.022903   |   0.0 |  0.02
Output  | 5.4363e-05 | 5.4363e-05 | 5.4363e-05 |   0.0 |  0.00
Modify  | 0.12331    | 0.12331    | 0.12331    |   0.0 |  0.11
Other   |            | 0.01057    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6093 ave        6093 max        6093 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540738 ave      540738 max      540738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540738
Ave neighs/atom = 135.1845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.871608943443, Press = -0.283836403990211
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17516.773     -17516.773     -17656.262     -17656.262      269.8498       269.8498       44088.61       44088.61       555.4125       555.4125     
     61000  -17516.951     -17516.951     -17658.061     -17658.061      272.98591      272.98591      44125.814      44125.814     -1146.1581     -1146.1581    
Loop time of 114.816 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.893 hours/ns, 8.710 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    | 114.66     | 114.66     | 114.66     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022729   | 0.022729   | 0.022729   |   0.0 |  0.02
Output  | 5.3401e-05 | 5.3401e-05 | 5.3401e-05 |   0.0 |  0.00
Modify  | 0.12349    | 0.12349    | 0.12349    |   0.0 |  0.11
Other   |            | 0.01057    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6070 ave        6070 max        6070 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540840 ave      540840 max      540840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540840
Ave neighs/atom = 135.21
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.846006911847, Press = -0.398857848718741
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17516.951     -17516.951     -17658.061     -17658.061      272.98591      272.98591      44125.814      44125.814     -1146.1581     -1146.1581    
     62000  -17513.021     -17513.021     -17656.725     -17656.725      278.00391      278.00391      44078.348      44078.348      1089.5593      1089.5593    
Loop time of 114.772 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.881 hours/ns, 8.713 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    | 114.62     | 114.62     | 114.62     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023012   | 0.023012   | 0.023012   |   0.0 |  0.02
Output  | 5.7107e-05 | 5.7107e-05 | 5.7107e-05 |   0.0 |  0.00
Modify  | 0.12327    | 0.12327    | 0.12327    |   0.0 |  0.11
Other   |            | 0.01062    |            |       |  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:       540658 ave      540658 max      540658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540658
Ave neighs/atom = 135.1645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.860565351672, Press = -1.33309835199244
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17513.021     -17513.021     -17656.725     -17656.725      278.00391      278.00391      44078.348      44078.348      1089.5593      1089.5593    
     63000  -17515.812     -17515.812     -17656.259     -17656.259      271.70428      271.70428      44084.397      44084.397      710.29741      710.29741    
Loop time of 114.967 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.752 ns/day, 31.935 hours/ns, 8.698 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    | 114.81     | 114.81     | 114.81     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022914   | 0.022914   | 0.022914   |   0.0 |  0.02
Output  | 5.0384e-05 | 5.0384e-05 | 5.0384e-05 |   0.0 |  0.00
Modify  | 0.12332    | 0.12332    | 0.12332    |   0.0 |  0.11
Other   |            | 0.01056    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6091 ave        6091 max        6091 min
Histogram: 1 0 0 0 0 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.872415183465, Press = 0.51194895410177
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17515.812     -17515.812     -17656.259     -17656.259      271.70428      271.70428      44084.397      44084.397      710.29741      710.29741    
     64000  -17516.199     -17516.199     -17659.245     -17659.245      276.73327      276.73327      44137.405      44137.405     -1666.0829     -1666.0829    
Loop time of 114.826 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.752 ns/day, 31.896 hours/ns, 8.709 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    | 114.67     | 114.67     | 114.67     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023048   | 0.023048   | 0.023048   |   0.0 |  0.02
Output  | 5.8591e-05 | 5.8591e-05 | 5.8591e-05 |   0.0 |  0.00
Modify  | 0.12305    | 0.12305    | 0.12305    |   0.0 |  0.11
Other   |            | 0.01064    |            |       |  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:       540854 ave      540854 max      540854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540854
Ave neighs/atom = 135.2135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.906429011732, Press = -0.914010616161064
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     64000  -17516.199     -17516.199     -17659.245     -17659.245      276.73327      276.73327      44137.405      44137.405     -1666.0829     -1666.0829    
     65000  -17512.8       -17512.8       -17653.969     -17653.969      273.10158      273.10158      44087.918      44087.918      873.7323       873.7323     
Loop time of 114.591 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.754 ns/day, 31.831 hours/ns, 8.727 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    | 114.43     | 114.43     | 114.43     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022698   | 0.022698   | 0.022698   |   0.0 |  0.02
Output  | 5.2739e-05 | 5.2739e-05 | 5.2739e-05 |   0.0 |  0.00
Modify  | 0.12324    | 0.12324    | 0.12324    |   0.0 |  0.11
Other   |            | 0.01064    |            |       |  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:       540664 ave      540664 max      540664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540664
Ave neighs/atom = 135.166
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.923508320129, Press = -0.53520068898253
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17512.8       -17512.8       -17653.969     -17653.969      273.10158      273.10158      44087.918      44087.918      873.7323       873.7323     
     66000  -17518.451     -17518.451     -17658.975     -17658.975      271.85265      271.85265      44104.356      44104.356     -331.81762     -331.81762    
Loop time of 114.609 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.754 ns/day, 31.836 hours/ns, 8.725 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    | 114.45     | 114.45     | 114.45     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023018   | 0.023018   | 0.023018   |   0.0 |  0.02
Output  | 5.1968e-05 | 5.1968e-05 | 5.1968e-05 |   0.0 |  0.00
Modify  | 0.12342    | 0.12342    | 0.12342    |   0.0 |  0.11
Other   |            | 0.01062    |            |       |  0.01

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

Total # of neighbors = 540878
Ave neighs/atom = 135.2195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.939269727532, Press = -0.195399145580957
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17518.451     -17518.451     -17658.975     -17658.975      271.85265      271.85265      44104.356      44104.356     -331.81762     -331.81762    
     67000  -17514.687     -17514.687     -17655.828     -17655.828      273.04702      273.04702      44111.449      44111.449     -344.98459     -344.98459    
Loop time of 114.632 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.754 ns/day, 31.842 hours/ns, 8.724 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    | 114.48     | 114.48     | 114.48     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022809   | 0.022809   | 0.022809   |   0.0 |  0.02
Output  | 5.2329e-05 | 5.2329e-05 | 5.2329e-05 |   0.0 |  0.00
Modify  | 0.12313    | 0.12313    | 0.12313    |   0.0 |  0.11
Other   |            | 0.0106     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6083 ave        6083 max        6083 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540796 ave      540796 max      540796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540796
Ave neighs/atom = 135.199
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.921370056753, Press = -0.642830058675697
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17514.687     -17514.687     -17655.828     -17655.828      273.04702      273.04702      44111.449      44111.449     -344.98459     -344.98459    
     68000  -17521.641     -17521.641     -17661.819     -17661.819      271.18264      271.18264      44090.256      44090.256     -86.904065     -86.904065    
Loop time of 114.883 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.752 ns/day, 31.912 hours/ns, 8.704 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    | 114.73     | 114.73     | 114.73     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023072   | 0.023072   | 0.023072   |   0.0 |  0.02
Output  | 4.8772e-05 | 4.8772e-05 | 4.8772e-05 |   0.0 |  0.00
Modify  | 0.12344    | 0.12344    | 0.12344    |   0.0 |  0.11
Other   |            | 0.01065    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6131 ave        6131 max        6131 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540734 ave      540734 max      540734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540734
Ave neighs/atom = 135.1835
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.906355565494, Press = -0.511719077256869
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     68000  -17521.641     -17521.641     -17661.819     -17661.819      271.18264      271.18264      44090.256      44090.256     -86.904065     -86.904065    
     69000  -17514.458     -17514.458     -17657.401     -17657.401      276.53296      276.53296      44101.494      44101.494     -52.364832     -52.364832    
Loop time of 114.883 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.752 ns/day, 31.912 hours/ns, 8.705 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    | 114.73     | 114.73     | 114.73     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022771   | 0.022771   | 0.022771   |   0.0 |  0.02
Output  | 4.5656e-05 | 4.5656e-05 | 4.5656e-05 |   0.0 |  0.00
Modify  | 0.1236     | 0.1236     | 0.1236     |   0.0 |  0.11
Other   |            | 0.01058    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6059 ave        6059 max        6059 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540738 ave      540738 max      540738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540738
Ave neighs/atom = 135.1845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.894196423261, Press = -0.409301412973425
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17514.458     -17514.458     -17657.401     -17657.401      276.53296      276.53296      44101.494      44101.494     -52.364832     -52.364832    
     70000  -17517.062     -17517.062     -17657.001     -17657.001      270.72184      270.72184      44091.372      44091.372      317.91644      317.91644    
Loop time of 114.603 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.754 ns/day, 31.834 hours/ns, 8.726 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    | 114.45     | 114.45     | 114.45     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022955   | 0.022955   | 0.022955   |   0.0 |  0.02
Output  | 4.7148e-05 | 4.7148e-05 | 4.7148e-05 |   0.0 |  0.00
Modify  | 0.12308    | 0.12308    | 0.12308    |   0.0 |  0.11
Other   |            | 0.01058    |            |       |  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:       540766 ave      540766 max      540766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540766
Ave neighs/atom = 135.1915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.910827387354, Press = -0.567771416098053
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17517.062     -17517.062     -17657.001     -17657.001      270.72184      270.72184      44091.372      44091.372      317.91644      317.91644    
     71000  -17515.328     -17515.328     -17655.033     -17655.033      270.26902      270.26902      44106.078      44106.078     -24.248982     -24.248982    
Loop time of 114.732 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.870 hours/ns, 8.716 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    | 114.58     | 114.58     | 114.58     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022863   | 0.022863   | 0.022863   |   0.0 |  0.02
Output  | 4.5305e-05 | 4.5305e-05 | 4.5305e-05 |   0.0 |  0.00
Modify  | 0.12315    | 0.12315    | 0.12315    |   0.0 |  0.11
Other   |            | 0.01057    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6088 ave        6088 max        6088 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540930 ave      540930 max      540930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540930
Ave neighs/atom = 135.2325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.907823415861, Press = -0.124334814698435
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17515.328     -17515.328     -17655.033     -17655.033      270.26902      270.26902      44106.078      44106.078     -24.248982     -24.248982    
     72000  -17516.851     -17516.851     -17655.323     -17655.323      267.88179      267.88179      44124.504      44124.504     -917.51322     -917.51322    
Loop time of 114.875 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.752 ns/day, 31.910 hours/ns, 8.705 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    | 114.72     | 114.72     | 114.72     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023079   | 0.023079   | 0.023079   |   0.0 |  0.02
Output  | 4.4243e-05 | 4.4243e-05 | 4.4243e-05 |   0.0 |  0.00
Modify  | 0.12317    | 0.12317    | 0.12317    |   0.0 |  0.11
Other   |            | 0.0106     |            |       |  0.01

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

Total # of neighbors = 540818
Ave neighs/atom = 135.2045
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.915452982693, Press = -1.06697916782381
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     72000  -17516.851     -17516.851     -17655.323     -17655.323      267.88179      267.88179      44124.504      44124.504     -917.51322     -917.51322    
     73000  -17513.23      -17513.23      -17654.815     -17654.815      273.90641      273.90641      44055.706      44055.706      2114.9765      2114.9765    
Loop time of 114.788 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.885 hours/ns, 8.712 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    | 114.63     | 114.63     | 114.63     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022787   | 0.022787   | 0.022787   |   0.0 |  0.02
Output  | 4.0576e-05 | 4.0576e-05 | 4.0576e-05 |   0.0 |  0.00
Modify  | 0.12291    | 0.12291    | 0.12291    |   0.0 |  0.11
Other   |            | 0.01053    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6069 ave        6069 max        6069 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540766 ave      540766 max      540766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540766
Ave neighs/atom = 135.1915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.9164420037, Press = -0.336454378935136
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17513.23      -17513.23      -17654.815     -17654.815      273.90641      273.90641      44055.706      44055.706      2114.9765      2114.9765    
     74000  -17516.022     -17516.022     -17658.606     -17658.606      275.83782      275.83782      44141.886      44141.886     -1850.4626     -1850.4626    
Loop time of 114.703 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.862 hours/ns, 8.718 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    | 114.55     | 114.55     | 114.55     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022903   | 0.022903   | 0.022903   |   0.0 |  0.02
Output  | 4.273e-05  | 4.273e-05  | 4.273e-05  |   0.0 |  0.00
Modify  | 0.12331    | 0.12331    | 0.12331    |   0.0 |  0.11
Other   |            | 0.01057    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6101 ave        6101 max        6101 min
Histogram: 1 0 0 0 0 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"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.924293642732, Press = 0.192799049159081
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     74000  -17516.022     -17516.022     -17658.606     -17658.606      275.83782      275.83782      44141.886      44141.886     -1850.4626     -1850.4626    
     75000  -17512.764     -17512.764     -17655.23      -17655.23       275.61042      275.61042      44112.019      44112.019     -273.72173     -273.72173    
Loop time of 114.631 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.754 ns/day, 31.842 hours/ns, 8.724 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    | 114.48     | 114.48     | 114.48     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022736   | 0.022736   | 0.022736   |   0.0 |  0.02
Output  | 4.23e-05   | 4.23e-05   | 4.23e-05   |   0.0 |  0.00
Modify  | 0.12264    | 0.12264    | 0.12264    |   0.0 |  0.11
Other   |            | 0.01052    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6041 ave        6041 max        6041 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540540 ave      540540 max      540540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540540
Ave neighs/atom = 135.135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.92313959579, Press = -0.947690108905168
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17512.764     -17512.764     -17655.23      -17655.23       275.61042      275.61042      44112.019      44112.019     -273.72173     -273.72173    
     76000  -17517.565     -17517.565     -17658.552     -17658.552      272.74851      272.74851      44092.178      44092.178      228.86575      228.86575    
Loop time of 114.77 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.881 hours/ns, 8.713 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    | 114.61     | 114.61     | 114.61     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022914   | 0.022914   | 0.022914   |   0.0 |  0.02
Output  | 4.4514e-05 | 4.4514e-05 | 4.4514e-05 |   0.0 |  0.00
Modify  | 0.12283    | 0.12283    | 0.12283    |   0.0 |  0.11
Other   |            | 0.01052    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6099 ave        6099 max        6099 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540726 ave      540726 max      540726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540726
Ave neighs/atom = 135.1815
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.921339617284, Press = -0.281494056716472
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     76000  -17517.565     -17517.565     -17658.552     -17658.552      272.74851      272.74851      44092.178      44092.178      228.86575      228.86575    
     77000  -17516.663     -17516.663     -17658.868     -17658.868      275.10382      275.10382      44107.582      44107.582     -472.27153     -472.27153    
Loop time of 114.742 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.753 ns/day, 31.873 hours/ns, 8.715 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    | 114.59     | 114.59     | 114.59     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022949   | 0.022949   | 0.022949   |   0.0 |  0.02
Output  | 4.9803e-05 | 4.9803e-05 | 4.9803e-05 |   0.0 |  0.00
Modify  | 0.12319    | 0.12319    | 0.12319    |   0.0 |  0.11
Other   |            | 0.01054    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6071 ave        6071 max        6071 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540840 ave      540840 max      540840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540840
Ave neighs/atom = 135.21
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.943087128838, Press = -0.500909007086302
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     77000  -17516.663     -17516.663     -17658.868     -17658.868      275.10382      275.10382      44107.582      44107.582     -472.27153     -472.27153    
     78000  -17513.621     -17513.621     -17655.63      -17655.63       274.72517      274.72517      44092.27       44092.27       488.85939      488.85939    
Loop time of 114.634 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.754 ns/day, 31.843 hours/ns, 8.723 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    | 114.48     | 114.48     | 114.48     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022996   | 0.022996   | 0.022996   |   0.0 |  0.02
Output  | 4.813e-05  | 4.813e-05  | 4.813e-05  |   0.0 |  0.00
Modify  | 0.12285    | 0.12285    | 0.12285    |   0.0 |  0.11
Other   |            | 0.01056    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6089 ave        6089 max        6089 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540632 ave      540632 max      540632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540632
Ave neighs/atom = 135.158
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.958148788817, Press = -0.595551376291504
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     78000  -17513.621     -17513.621     -17655.63      -17655.63       274.72517      274.72517      44092.27       44092.27       488.85939      488.85939    
     79000  -17517.196     -17517.196     -17659.67      -17659.67       275.62604      275.62604      44099.595      44099.595     -147.32971     -147.32971    
Loop time of 114.552 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.754 ns/day, 31.820 hours/ns, 8.730 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    | 114.4      | 114.4      | 114.4      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022937   | 0.022937   | 0.022937   |   0.0 |  0.02
Output  | 4.5776e-05 | 4.5776e-05 | 4.5776e-05 |   0.0 |  0.00
Modify  | 0.12311    | 0.12311    | 0.12311    |   0.0 |  0.11
Other   |            | 0.0106     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6131 ave        6131 max        6131 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540878 ave      540878 max      540878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0