# 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_ShimKoKim_2013_NiVH__MO_612225165948_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_612225165948_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.3465     -1595.3465    
Loop time of 107.369 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.805 ns/day, 29.825 hours/ns, 9.314 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.21     | 107.21     | 107.21     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022806   | 0.022806   | 0.022806   |   0.0 |  0.02
Output  | 0.00016988 | 0.00016988 | 0.00016988 |   0.0 |  0.00
Modify  | 0.12316    | 0.12316    | 0.12316    |   0.0 |  0.11
Other   |            | 0.01179    |            |       |  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.3465     -1595.3465    
      2000  -17517.097     -17517.097     -17655.248     -17655.248      267.26217      267.26217      44092.267      44092.267      513.45589      513.45589    
Loop time of 113.088 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.764 ns/day, 31.413 hours/ns, 8.843 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.93     | 112.93     | 112.93     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022727   | 0.022727   | 0.022727   |   0.0 |  0.02
Output  | 7.7385e-05 | 7.7385e-05 | 7.7385e-05 |   0.0 |  0.00
Modify  | 0.12362    | 0.12362    | 0.12362    |   0.0 |  0.11
Other   |            | 0.01187    |            |       |  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.45589      513.45589    
      3000  -17516.726     -17516.726     -17657.17      -17657.17       271.69951      271.69951      44091.073      44091.073      359.78546      359.78546    
Loop time of 113.167 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.763 ns/day, 31.435 hours/ns, 8.836 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.01     | 113.01     | 113.01     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022762   | 0.022762   | 0.022762   |   0.0 |  0.02
Output  | 7.3578e-05 | 7.3578e-05 | 7.3578e-05 |   0.0 |  0.00
Modify  | 0.12351    | 0.12351    | 0.12351    |   0.0 |  0.11
Other   |            | 0.01193    |            |       |  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.78546      359.78546    
      4000  -17513.956     -17513.956     -17654.336     -17654.336      271.57441      271.57441      44109.023      44109.023     -41.664835     -41.664835    
Loop time of 112.834 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.766 ns/day, 31.343 hours/ns, 8.863 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.68     | 112.68     | 112.68     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022816   | 0.022816   | 0.022816   |   0.0 |  0.02
Output  | 7.1805e-05 | 7.1805e-05 | 7.1805e-05 |   0.0 |  0.00
Modify  | 0.12329    | 0.12329    | 0.12329    |   0.0 |  0.11
Other   |            | 0.01186    |            |       |  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.664835     -41.664835    
      5000  -17518.161     -17518.161     -17659.478     -17659.478      273.38583      273.38583      44103.642      44103.642     -295.97814     -295.97814    
Loop time of 112.989 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.765 ns/day, 31.386 hours/ns, 8.850 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.83     | 112.83     | 112.83     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023057   | 0.023057   | 0.023057   |   0.0 |  0.02
Output  | 4.9984e-05 | 4.9984e-05 | 4.9984e-05 |   0.0 |  0.00
Modify  | 0.12379    | 0.12379    | 0.12379    |   0.0 |  0.11
Other   |            | 0.01191    |            |       |  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.611135484742, Press = -333.668604224748
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.97814     -295.97814    
      6000  -17512.851     -17512.851     -17654.119     -17654.119      273.29247      273.29247      44060.629      44060.629      2027.4783      2027.4783    
Loop time of 113.042 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.764 ns/day, 31.400 hours/ns, 8.846 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.88     | 112.88     | 112.88     |   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.1787e-05 | 5.1787e-05 | 5.1787e-05 |   0.0 |  0.00
Modify  | 0.1275     | 0.1275     | 0.1275     |   0.0 |  0.11
Other   |            | 0.01187    |            |       |  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.788199576146, Press = 6.19618771474675
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.4783      2027.4783    
      7000  -17518.113     -17518.113     -17657.601     -17657.601      269.84982      269.84982      44152.994      44152.994     -2174.9729     -2174.9729    
Loop time of 112.966 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.765 ns/day, 31.379 hours/ns, 8.852 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.8      | 112.8      | 112.8      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022924   | 0.022924   | 0.022924   |   0.0 |  0.02
Output  | 4.9884e-05 | 4.9884e-05 | 4.9884e-05 |   0.0 |  0.00
Modify  | 0.12888    | 0.12888    | 0.12888    |   0.0 |  0.11
Other   |            | 0.01194    |            |       |  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.017667507363, Press = 7.4224975395975
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.9729     -2174.9729    
      8000  -17515.198     -17515.198     -17660.324     -17660.324      280.75567      280.75567      44097.634      44097.634     -104.30522     -104.30522    
Loop time of 112.804 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.766 ns/day, 31.334 hours/ns, 8.865 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.64     | 112.64     | 112.64     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022732   | 0.022732   | 0.022732   |   0.0 |  0.02
Output  | 5.1307e-05 | 5.1307e-05 | 5.1307e-05 |   0.0 |  0.00
Modify  | 0.12884    | 0.12884    | 0.12884    |   0.0 |  0.11
Other   |            | 0.01186    |            |       |  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.964957680223, Press = -22.1650946087807
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.30522     -104.30522    
      9000  -17519.002     -17519.002     -17659.503     -17659.503      271.80964      271.80964      44081.577      44081.577      584.35226      584.35226    
Loop time of 112.9 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.765 ns/day, 31.361 hours/ns, 8.857 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.74     | 112.74     | 112.74     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022959   | 0.022959   | 0.022959   |   0.0 |  0.02
Output  | 4.8712e-05 | 4.8712e-05 | 4.8712e-05 |   0.0 |  0.00
Modify  | 0.12811    | 0.12811    | 0.12811    |   0.0 |  0.11
Other   |            | 0.01192    |            |       |  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.602527149107, Press = 1.69507313131282
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.35226      584.35226    
     10000  -17509.556     -17509.556     -17653.353     -17653.353      278.18349      278.18349      44139.015      44139.015     -1088.1316     -1088.1316    
Loop time of 113.247 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.763 ns/day, 31.458 hours/ns, 8.830 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.08     | 113.08     | 113.08     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022688   | 0.022688   | 0.022688   |   0.0 |  0.02
Output  | 4.6758e-05 | 4.6758e-05 | 4.6758e-05 |   0.0 |  0.00
Modify  | 0.12848    | 0.12848    | 0.12848    |   0.0 |  0.11
Other   |            | 0.01142    |            |       |  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.920792492948, Press = -2.82755327087972
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.18349      278.18349      44139.015      44139.015     -1088.1316     -1088.1316    
     11000  -17517.61      -17517.61      -17654.684     -17654.684      265.17787      265.17787      44083.794      44083.794      858.00608      858.00608    
Loop time of 112.852 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.766 ns/day, 31.348 hours/ns, 8.861 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.69     | 112.69     | 112.69     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0228     | 0.0228     | 0.0228     |   0.0 |  0.02
Output  | 4.7459e-05 | 4.7459e-05 | 4.7459e-05 |   0.0 |  0.00
Modify  | 0.128      | 0.128      | 0.128      |   0.0 |  0.11
Other   |            | 0.01142    |            |       |  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.111361626497, Press = -5.06891605340699
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.00608      858.00608    
     12000  -17519.845     -17519.845     -17660.93      -17660.93       272.93851      272.93851      44077.692      44077.692      626.52631      626.52631    
Loop time of 112.765 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.766 ns/day, 31.324 hours/ns, 8.868 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.6      | 112.6      | 112.6      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022896   | 0.022896   | 0.022896   |   0.0 |  0.02
Output  | 4.5776e-05 | 4.5776e-05 | 4.5776e-05 |   0.0 |  0.00
Modify  | 0.12827    | 0.12827    | 0.12827    |   0.0 |  0.11
Other   |            | 0.01194    |            |       |  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.17010306361, Press = 6.06944595286624
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.52631      626.52631    
     13000  -17515.301     -17515.301     -17658.844     -17658.844      277.69311      277.69311      44168.989      44168.989     -2879.6624     -2879.6624    
Loop time of 113.002 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.765 ns/day, 31.389 hours/ns, 8.849 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.84     | 112.84     | 112.84     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023192   | 0.023192   | 0.023192   |   0.0 |  0.02
Output  | 4.6377e-05 | 4.6377e-05 | 4.6377e-05 |   0.0 |  0.00
Modify  | 0.12827    | 0.12827    | 0.12827    |   0.0 |  0.11
Other   |            | 0.01151    |            |       |  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.041614194992, Press = -4.17403546530816
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.69311      277.69311      44168.989      44168.989     -2879.6624     -2879.6624    
     14000  -17520.905     -17520.905     -17661.443     -17661.443      271.87898      271.87898      44067.122      44067.122      971.53909      971.53909    
Loop time of 112.641 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.767 ns/day, 31.289 hours/ns, 8.878 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.48     | 112.48     | 112.48     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022498   | 0.022498   | 0.022498   |   0.0 |  0.02
Output  | 7.8097e-05 | 7.8097e-05 | 7.8097e-05 |   0.0 |  0.00
Modify  | 0.12724    | 0.12724    | 0.12724    |   0.0 |  0.11
Other   |            | 0.01138    |            |       |  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.838299015398, Press = -4.43013451792381
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.905     -17520.905     -17661.443     -17661.443      271.87898      271.87898      44067.122      44067.122      971.53909      971.53909    
     15000  -17517.759     -17517.759     -17657.375     -17657.375      270.09705      270.09705      44096.814      44096.814      152.41356      152.41356    
Loop time of 112.924 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.765 ns/day, 31.368 hours/ns, 8.856 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.76     | 112.76     | 112.76     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023136   | 0.023136   | 0.023136   |   0.0 |  0.02
Output  | 4.805e-05  | 4.805e-05  | 4.805e-05  |   0.0 |  0.00
Modify  | 0.12835    | 0.12835    | 0.12835    |   0.0 |  0.11
Other   |            | 0.01197    |            |       |  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.824873617638, Press = 1.52568070676748
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.09705      270.09705      44096.814      44096.814      152.41356      152.41356    
     16000  -17513.576     -17513.576     -17658.037     -17658.037      279.47024      279.47024      44126.703      44126.703     -1048.9056     -1048.9056    
Loop time of 112.821 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.766 ns/day, 31.339 hours/ns, 8.864 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.66     | 112.66     | 112.66     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022631   | 0.022631   | 0.022631   |   0.0 |  0.02
Output  | 4.793e-05  | 4.793e-05  | 4.793e-05  |   0.0 |  0.00
Modify  | 0.12796    | 0.12796    | 0.12796    |   0.0 |  0.11
Other   |            | 0.01139    |            |       |  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.766943782368, Press = -2.13066216946562
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.47024      279.47024      44126.703      44126.703     -1048.9056     -1048.9056    
     17000  -17520.547     -17520.547     -17660.342     -17660.342      270.44361      270.44361      44076.825      44076.825      633.30778      633.30778    
Loop time of 112.899 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.765 ns/day, 31.361 hours/ns, 8.858 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.74     | 112.74     | 112.74     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022886   | 0.022886   | 0.022886   |   0.0 |  0.02
Output  | 4.9513e-05 | 4.9513e-05 | 4.9513e-05 |   0.0 |  0.00
Modify  | 0.12819    | 0.12819    | 0.12819    |   0.0 |  0.11
Other   |            | 0.01197    |            |       |  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.733102372646, Press = -2.64156581958517
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.44361      270.44361      44076.825      44076.825      633.30778      633.30778    
     18000  -17515.035     -17515.035     -17657.614     -17657.614      275.82733      275.82733      44069.344      44069.344      1227.2936      1227.2936    
Loop time of 112.779 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.766 ns/day, 31.327 hours/ns, 8.867 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.62     | 112.62     | 112.62     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022631   | 0.022631   | 0.022631   |   0.0 |  0.02
Output  | 4.9153e-05 | 4.9153e-05 | 4.9153e-05 |   0.0 |  0.00
Modify  | 0.128      | 0.128      | 0.128      |   0.0 |  0.11
Other   |            | 0.012      |            |       |  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.665526613402, Press = 3.63734420074536
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.035     -17515.035     -17657.614     -17657.614      275.82733      275.82733      44069.344      44069.344      1227.2936      1227.2936    
     19000  -17517.973     -17517.973     -17658.63      -17658.63       272.11065      272.11065      44151.965      44151.965     -2274.8519     -2274.8519    
Loop time of 112.779 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.766 ns/day, 31.328 hours/ns, 8.867 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.62     | 112.62     | 112.62     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023137   | 0.023137   | 0.023137   |   0.0 |  0.02
Output  | 4.8541e-05 | 4.8541e-05 | 4.8541e-05 |   0.0 |  0.00
Modify  | 0.12816    | 0.12816    | 0.12816    |   0.0 |  0.11
Other   |            | 0.01189    |            |       |  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.640695468791, Press = -2.12131707219222
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.973     -17517.973     -17658.63      -17658.63       272.11065      272.11065      44151.965      44151.965     -2274.8519     -2274.8519    
     20000  -17516.075     -17516.075     -17656.327     -17656.327      271.3264       271.3264       44070.287      44070.287      1362.2047      1362.2047    
Loop time of 112.635 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.767 ns/day, 31.288 hours/ns, 8.878 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.47     | 112.47     | 112.47     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022485   | 0.022485   | 0.022485   |   0.0 |  0.02
Output  | 4.7529e-05 | 4.7529e-05 | 4.7529e-05 |   0.0 |  0.00
Modify  | 0.12819    | 0.12819    | 0.12819    |   0.0 |  0.11
Other   |            | 0.01207    |            |       |  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.61417173074, Press = -1.78510190727628
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.075     -17516.075     -17656.327     -17656.327      271.3264       271.3264       44070.287      44070.287      1362.2047      1362.2047    
     21000  -17518.512     -17518.512     -17660.999     -17660.999      275.64935      275.64935      44104.955      44104.955     -530.02627     -530.02627    
Loop time of 112.853 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.766 ns/day, 31.348 hours/ns, 8.861 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.69     | 112.69     | 112.69     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024193   | 0.024193   | 0.024193   |   0.0 |  0.02
Output  | 4.5095e-05 | 4.5095e-05 | 4.5095e-05 |   0.0 |  0.00
Modify  | 0.128      | 0.128      | 0.128      |   0.0 |  0.11
Other   |            | 0.01208    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6203 ave        6203 max        6203 min
Histogram: 1 0 0 0 0 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.504043287617, Press = 1.70468322494277
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.512     -17518.512     -17660.999     -17660.999      275.64935      275.64935      44104.955      44104.955     -530.02627     -530.02627    
     22000  -17517.48      -17517.48      -17658.658     -17658.658      273.11856      273.11856      44120.182      44120.182     -945.89958     -945.89958    
Loop time of 112.808 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.766 ns/day, 31.336 hours/ns, 8.865 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.65     | 112.65     | 112.65     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022747   | 0.022747   | 0.022747   |   0.0 |  0.02
Output  | 4.3112e-05 | 4.3112e-05 | 4.3112e-05 |   0.0 |  0.00
Modify  | 0.12793    | 0.12793    | 0.12793    |   0.0 |  0.11
Other   |            | 0.01225    |            |       |  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:       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.534857124655, Press = -1.71098649974006
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.48      -17517.48      -17658.658     -17658.658      273.11856      273.11856      44120.182      44120.182     -945.89958     -945.89958    
     23000  -17513.996     -17513.996     -17656.731     -17656.731      276.13156      276.13156      44095.345      44095.345      304.64393      304.64393    
Loop time of 112.76 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.766 ns/day, 31.322 hours/ns, 8.868 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.6      | 112.6      | 112.6      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022729   | 0.022729   | 0.022729   |   0.0 |  0.02
Output  | 4.8581e-05 | 4.8581e-05 | 4.8581e-05 |   0.0 |  0.00
Modify  | 0.12811    | 0.12811    | 0.12811    |   0.0 |  0.11
Other   |            | 0.01199    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6146 ave        6146 max        6146 min
Histogram: 1 0 0 0 0 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.536208560018, Press = -0.331018581845144
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17513.996     -17513.996     -17656.731     -17656.731      276.13156      276.13156      44095.345      44095.345      304.64393      304.64393    
     24000  -17518.59      -17518.59      -17659.231     -17659.231      272.0798       272.0798       44102.464      44102.464     -319.38879     -319.38879    
Loop time of 112.43 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.231 hours/ns, 8.894 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.27     | 112.27     | 112.27     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022457   | 0.022457   | 0.022457   |   0.0 |  0.02
Output  | 4.8582e-05 | 4.8582e-05 | 4.8582e-05 |   0.0 |  0.00
Modify  | 0.1274     | 0.1274     | 0.1274     |   0.0 |  0.11
Other   |            | 0.01194    |            |       |  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:       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.566770205556, Press = -0.299087498197192
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.59      -17518.59      -17659.231     -17659.231      272.0798       272.0798       44102.464      44102.464     -319.38879     -319.38879    
     25000  -17513.953     -17513.953     -17655.305     -17655.305      273.4545       273.4545       44111.132      44111.132     -247.88445     -247.88445    
Loop time of 112.482 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.245 hours/ns, 8.890 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.32     | 112.32     | 112.32     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022692   | 0.022692   | 0.022692   |   0.0 |  0.02
Output  | 4.7089e-05 | 4.7089e-05 | 4.7089e-05 |   0.0 |  0.00
Modify  | 0.12847    | 0.12847    | 0.12847    |   0.0 |  0.11
Other   |            | 0.0121     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6115 ave        6115 max        6115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540814 ave      540814 max      540814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540814
Ave neighs/atom = 135.2035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.513123761345, Press = -0.646015449002818
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17513.953     -17513.953     -17655.305     -17655.305      273.4545       273.4545       44111.132      44111.132     -247.88445     -247.88445    
     26000  -17521.472     -17521.472     -17657.802     -17657.802      263.73925      263.73925      44082.552      44082.552      597.60965      597.60965    
Loop time of 112.522 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.256 hours/ns, 8.887 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.36     | 112.36     | 112.36     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022682   | 0.022682   | 0.022682   |   0.0 |  0.02
Output  | 4.8441e-05 | 4.8441e-05 | 4.8441e-05 |   0.0 |  0.00
Modify  | 0.12803    | 0.12803    | 0.12803    |   0.0 |  0.11
Other   |            | 0.01227    |            |       |  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:       540758 ave      540758 max      540758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540758
Ave neighs/atom = 135.1895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.503643354969, Press = -1.24875801524809
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17521.472     -17521.472     -17657.802     -17657.802      263.73925      263.73925      44082.552      44082.552      597.60965      597.60965    
     27000  -17516.246     -17516.246     -17658.533     -17658.533      275.2635       275.2635       44103.348      44103.348     -274.30835     -274.30835    
Loop time of 112.679 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.767 ns/day, 31.300 hours/ns, 8.875 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.52     | 112.52     | 112.52     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022897   | 0.022897   | 0.022897   |   0.0 |  0.02
Output  | 4.8751e-05 | 4.8751e-05 | 4.8751e-05 |   0.0 |  0.00
Modify  | 0.128      | 0.128      | 0.128      |   0.0 |  0.11
Other   |            | 0.01196    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6104 ave        6104 max        6104 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540838 ave      540838 max      540838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540838
Ave neighs/atom = 135.2095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.51191333995, Press = -0.191805454850535
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17516.246     -17516.246     -17658.533     -17658.533      275.2635       275.2635       44103.348      44103.348     -274.30835     -274.30835    
     28000  -17517.765     -17517.765     -17657.743     -17657.743      270.79681      270.79681      44111.996      44111.996     -574.00503     -574.00503    
Loop time of 112.508 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.252 hours/ns, 8.888 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.35     | 112.35     | 112.35     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022681   | 0.022681   | 0.022681   |   0.0 |  0.02
Output  | 4.6928e-05 | 4.6928e-05 | 4.6928e-05 |   0.0 |  0.00
Modify  | 0.12722    | 0.12722    | 0.12722    |   0.0 |  0.11
Other   |            | 0.01193    |            |       |  0.01

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

Total # of neighbors = 540756
Ave neighs/atom = 135.189
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.516260565404, Press = -1.61956381715905
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17517.765     -17517.765     -17657.743     -17657.743      270.79681      270.79681      44111.996      44111.996     -574.00503     -574.00503    
     29000  -17514.55      -17514.55      -17655.141     -17655.141      271.98282      271.98282      44053.817      44053.817      2174.2656      2174.2656    
Loop time of 112.784 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.766 ns/day, 31.329 hours/ns, 8.867 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.62     | 112.62     | 112.62     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022786   | 0.022786   | 0.022786   |   0.0 |  0.02
Output  | 4.6547e-05 | 4.6547e-05 | 4.6547e-05 |   0.0 |  0.00
Modify  | 0.12791    | 0.12791    | 0.12791    |   0.0 |  0.11
Other   |            | 0.01197    |            |       |  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:       540720 ave      540720 max      540720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540720
Ave neighs/atom = 135.18
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.520088580076, Press = -0.885993636217439
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17514.55      -17514.55      -17655.141     -17655.141      271.98282      271.98282      44053.817      44053.817      2174.2656      2174.2656    
     30000  -17515.958     -17515.958     -17656.862     -17656.862      272.5871       272.5871       44125.534      44125.534     -1044.0207     -1044.0207    
Loop time of 112.427 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.230 hours/ns, 8.895 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.27     | 112.27     | 112.27     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022821   | 0.022821   | 0.022821   |   0.0 |  0.02
Output  | 4.8491e-05 | 4.8491e-05 | 4.8491e-05 |   0.0 |  0.00
Modify  | 0.12482    | 0.12482    | 0.12482    |   0.0 |  0.11
Other   |            | 0.01139    |            |       |  0.01

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

Total # of neighbors = 540954
Ave neighs/atom = 135.2385
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.520669102601, Press = 1.65200657755332
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17515.958     -17515.958     -17656.862     -17656.862      272.5871       272.5871       44125.534      44125.534     -1044.0207     -1044.0207    
     31000  -17517.7       -17517.7       -17657.352     -17657.352      270.16485      270.16485      44115.595      44115.595     -685.87439     -685.87439    
Loop time of 112.412 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.226 hours/ns, 8.896 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.26     | 112.26     | 112.26     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022493   | 0.022493   | 0.022493   |   0.0 |  0.02
Output  | 4.6398e-05 | 4.6398e-05 | 4.6398e-05 |   0.0 |  0.00
Modify  | 0.12241    | 0.12241    | 0.12241    |   0.0 |  0.11
Other   |            | 0.01102    |            |       |  0.01

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

Total # of neighbors = 540638
Ave neighs/atom = 135.1595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.583909411997, Press = -2.08136887490361
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17517.7       -17517.7       -17657.352     -17657.352      270.16485      270.16485      44115.595      44115.595     -685.87439     -685.87439    
     32000  -17514.948     -17514.948     -17656.981     -17656.981      274.77351      274.77351      44089.197      44089.197      439.11913      439.11913    
Loop time of 112.414 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.226 hours/ns, 8.896 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.26     | 112.26     | 112.26     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022481   | 0.022481   | 0.022481   |   0.0 |  0.02
Output  | 4.4233e-05 | 4.4233e-05 | 4.4233e-05 |   0.0 |  0.00
Modify  | 0.12249    | 0.12249    | 0.12249    |   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:           6096 ave        6096 max        6096 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540648 ave      540648 max      540648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540648
Ave neighs/atom = 135.162
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.648249047824, Press = -0.489828025750238
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17514.948     -17514.948     -17656.981     -17656.981      274.77351      274.77351      44089.197      44089.197      439.11913      439.11913    
     33000  -17519.398     -17519.398     -17658.89      -17658.89       269.85643      269.85643      44105.16       44105.16      -447.50257     -447.50257    
Loop time of 112.342 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.206 hours/ns, 8.901 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.19     | 112.19     | 112.19     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022444   | 0.022444   | 0.022444   |   0.0 |  0.02
Output  | 4.9103e-05 | 4.9103e-05 | 4.9103e-05 |   0.0 |  0.00
Modify  | 0.1232     | 0.1232     | 0.1232     |   0.0 |  0.11
Other   |            | 0.011      |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6121 ave        6121 max        6121 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 272.684672039586, Press = -0.372783354953706
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17519.398     -17519.398     -17658.89      -17658.89       269.85643      269.85643      44105.16       44105.16      -447.50257     -447.50257    
     34000  -17512.327     -17512.327     -17654.322     -17654.322      274.6984       274.6984       44107.887      44107.887      46.091179      46.091179    
Loop time of 112.386 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.218 hours/ns, 8.898 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.23     | 112.23     | 112.23     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022561   | 0.022561   | 0.022561   |   0.0 |  0.02
Output  | 4.6728e-05 | 4.6728e-05 | 4.6728e-05 |   0.0 |  0.00
Modify  | 0.12268    | 0.12268    | 0.12268    |   0.0 |  0.11
Other   |            | 0.01122    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6154 ave        6154 max        6154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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.720369042317, Press = -1.11811006977032
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17512.327     -17512.327     -17654.322     -17654.322      274.6984       274.6984       44107.887      44107.887      46.091179      46.091179    
     35000  -17517.822     -17517.822     -17657.432     -17657.432      270.08437      270.08437      44072.922      44072.922      1078.7241      1078.7241    
Loop time of 112.477 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.244 hours/ns, 8.891 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.32     | 112.32     | 112.32     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022581   | 0.022581   | 0.022581   |   0.0 |  0.02
Output  | 4.6939e-05 | 4.6939e-05 | 4.6939e-05 |   0.0 |  0.00
Modify  | 0.12238    | 0.12238    | 0.12238    |   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:           6137 ave        6137 max        6137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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.737266790275, Press = 0.334336491295993
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17517.822     -17517.822     -17657.432     -17657.432      270.08437      270.08437      44072.922      44072.922      1078.7241      1078.7241    
     36000  -17514.736     -17514.736     -17656.681     -17656.681      274.6024       274.6024       44150.301      44150.301     -1950.9234     -1950.9234    
Loop time of 112.249 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.180 hours/ns, 8.909 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.09     | 112.09     | 112.09     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022689   | 0.022689   | 0.022689   |   0.0 |  0.02
Output  | 5.0275e-05 | 5.0275e-05 | 5.0275e-05 |   0.0 |  0.00
Modify  | 0.12294    | 0.12294    | 0.12294    |   0.0 |  0.11
Other   |            | 0.01106    |            |       |  0.01

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

Total # of neighbors = 540910
Ave neighs/atom = 135.2275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.776910992137, Press = -0.472574692626507
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.736     -17514.736     -17656.681     -17656.681      274.6024       274.6024       44150.301      44150.301     -1950.9234     -1950.9234    
     37000  -17515.708     -17515.708     -17657.009     -17657.009      273.35589      273.35589      44076.65       44076.65       1075.4541      1075.4541    
Loop time of 112.365 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.213 hours/ns, 8.900 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.21     | 112.21     | 112.21     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022593   | 0.022593   | 0.022593   |   0.0 |  0.02
Output  | 4.9132e-05 | 4.9132e-05 | 4.9132e-05 |   0.0 |  0.00
Modify  | 0.12254    | 0.12254    | 0.12254    |   0.0 |  0.11
Other   |            | 0.01114    |            |       |  0.01

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

Total # of neighbors = 540528
Ave neighs/atom = 135.132
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.77749784802, Press = -1.92196349575602
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     37000  -17515.708     -17515.708     -17657.009     -17657.009      273.35589      273.35589      44076.65       44076.65       1075.4541      1075.4541    
     38000  -17514.996     -17514.996     -17656.922     -17656.922      274.56468      274.56468      44087.302      44087.302      586.38165      586.38165    
Loop time of 112.534 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.259 hours/ns, 8.886 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.38     | 112.38     | 112.38     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022399   | 0.022399   | 0.022399   |   0.0 |  0.02
Output  | 5.0144e-05 | 5.0144e-05 | 5.0144e-05 |   0.0 |  0.00
Modify  | 0.12232    | 0.12232    | 0.12232    |   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:           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:       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.778366552654, Press = 0.917471299946914
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17514.996     -17514.996     -17656.922     -17656.922      274.56468      274.56468      44087.302      44087.302      586.38165      586.38165    
     39000  -17518.818     -17518.818     -17657.762     -17657.762      268.79685      268.79685      44115.349      44115.349     -664.82422     -664.82422    
Loop time of 112.56 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.267 hours/ns, 8.884 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    | 112.4      | 112.4      | 112.4      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022712   | 0.022712   | 0.022712   |   0.0 |  0.02
Output  | 3.2451e-05 | 3.2451e-05 | 3.2451e-05 |   0.0 |  0.00
Modify  | 0.12282    | 0.12282    | 0.12282    |   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:       540978 ave      540978 max      540978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540978
Ave neighs/atom = 135.2445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.802635591857, Press = -0.724821367266343
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.818     -17518.818     -17657.762     -17657.762      268.79685      268.79685      44115.349      44115.349     -664.82422     -664.82422    
     40000  -17513.226     -17513.226     -17655.758     -17655.758      275.73733      275.73733      44096.494      44096.494      326.39905      326.39905    
Loop time of 112.704 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.767 ns/day, 31.307 hours/ns, 8.873 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    | 112.55     | 112.55     | 112.55     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022591   | 0.022591   | 0.022591   |   0.0 |  0.02
Output  | 4.7239e-05 | 4.7239e-05 | 4.7239e-05 |   0.0 |  0.00
Modify  | 0.12284    | 0.12284    | 0.12284    |   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:           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:       540718 ave      540718 max      540718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540718
Ave neighs/atom = 135.1795
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.83768567793, Press = -0.767793376087445
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17513.226     -17513.226     -17655.758     -17655.758      275.73733      275.73733      44096.494      44096.494      326.39905      326.39905    
     41000  -17515.716     -17515.716     -17655.069     -17655.069      269.58947      269.58947      44094.029      44094.029      467.51529      467.51529    
Loop time of 112.792 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.766 ns/day, 31.331 hours/ns, 8.866 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    | 112.64     | 112.64     | 112.64     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022568   | 0.022568   | 0.022568   |   0.0 |  0.02
Output  | 4.8051e-05 | 4.8051e-05 | 4.8051e-05 |   0.0 |  0.00
Modify  | 0.12288    | 0.12288    | 0.12288    |   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:           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:       540786 ave      540786 max      540786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540786
Ave neighs/atom = 135.1965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.86325639732, Press = 0.114514881293532
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17515.716     -17515.716     -17655.069     -17655.069      269.58947      269.58947      44094.029      44094.029      467.51529      467.51529    
     42000  -17513.101     -17513.101     -17653.893     -17653.893      272.3723       272.3723       44125.14       44125.14      -739.69392     -739.69392    
Loop time of 112.434 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.232 hours/ns, 8.894 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    | 112.28     | 112.28     | 112.28     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022556   | 0.022556   | 0.022556   |   0.0 |  0.02
Output  | 4.8641e-05 | 4.8641e-05 | 4.8641e-05 |   0.0 |  0.00
Modify  | 0.12351    | 0.12351    | 0.12351    |   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:           6104 ave        6104 max        6104 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540814 ave      540814 max      540814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540814
Ave neighs/atom = 135.2035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.914606542296, Press = -0.795333487248065
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.101     -17513.101     -17653.893     -17653.893      272.3723       272.3723       44125.14       44125.14      -739.69392     -739.69392    
     43000  -17515.042     -17515.042     -17654.767     -17654.767      270.30697      270.30697      44086.339      44086.339      765.87534      765.87534    
Loop time of 112.468 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.241 hours/ns, 8.891 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    | 112.31     | 112.31     | 112.31     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022488   | 0.022488   | 0.022488   |   0.0 |  0.02
Output  | 4.8501e-05 | 4.8501e-05 | 4.8501e-05 |   0.0 |  0.00
Modify  | 0.12258    | 0.12258    | 0.12258    |   0.0 |  0.11
Other   |            | 0.0112     |            |       |  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:       540858 ave      540858 max      540858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540858
Ave neighs/atom = 135.2145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.891615799859, Press = -1.05851461436882
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.042     -17515.042     -17654.767     -17654.767      270.30697      270.30697      44086.339      44086.339      765.87534      765.87534    
     44000  -17514.705     -17514.705     -17655.233     -17655.233      271.86211      271.86211      44096.675      44096.675      337.85639      337.85639    
Loop time of 112.666 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.767 ns/day, 31.296 hours/ns, 8.876 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    | 112.51     | 112.51     | 112.51     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02249    | 0.02249    | 0.02249    |   0.0 |  0.02
Output  | 4.8672e-05 | 4.8672e-05 | 4.8672e-05 |   0.0 |  0.00
Modify  | 0.12259    | 0.12259    | 0.12259    |   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:           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:       540940 ave      540940 max      540940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540940
Ave neighs/atom = 135.235
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.87866335464, Press = 0.294260174755958
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17514.705     -17514.705     -17655.233     -17655.233      271.86211      271.86211      44096.675      44096.675      337.85639      337.85639    
     45000  -17510.781     -17510.781     -17653.642     -17653.642      276.37508      276.37508      44133.194      44133.194     -893.51484     -893.51484    
Loop time of 112.518 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.255 hours/ns, 8.887 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    | 112.36     | 112.36     | 112.36     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022803   | 0.022803   | 0.022803   |   0.0 |  0.02
Output  | 8.3768e-05 | 8.3768e-05 | 8.3768e-05 |   0.0 |  0.00
Modify  | 0.12332    | 0.12332    | 0.12332    |   0.0 |  0.11
Other   |            | 0.01102    |            |       |  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:       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.888535257116, Press = -1.25410731988728
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17510.781     -17510.781     -17653.642     -17653.642      276.37508      276.37508      44133.194      44133.194     -893.51484     -893.51484    
     46000  -17516.683     -17516.683     -17656.278     -17656.278      270.05655      270.05655      44052.568      44052.568      2033.6852      2033.6852    
Loop time of 112.386 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.218 hours/ns, 8.898 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    | 112.23     | 112.23     | 112.23     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02245    | 0.02245    | 0.02245    |   0.0 |  0.02
Output  | 4.7499e-05 | 4.7499e-05 | 4.7499e-05 |   0.0 |  0.00
Modify  | 0.12275    | 0.12275    | 0.12275    |   0.0 |  0.11
Other   |            | 0.01127    |            |       |  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:       540566 ave      540566 max      540566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540566
Ave neighs/atom = 135.1415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.926165607817, Press = -0.662274709311832
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17516.683     -17516.683     -17656.278     -17656.278      270.05655      270.05655      44052.568      44052.568      2033.6852      2033.6852    
     47000  -17514.815     -17514.815     -17654.935     -17654.935      271.07249      271.07249      44130.907      44130.907     -1091.713      -1091.713     
Loop time of 112.235 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.176 hours/ns, 8.910 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    | 112.08     | 112.08     | 112.08     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022521   | 0.022521   | 0.022521   |   0.0 |  0.02
Output  | 5.0445e-05 | 5.0445e-05 | 5.0445e-05 |   0.0 |  0.00
Modify  | 0.12234    | 0.12234    | 0.12234    |   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:           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:       541076 ave      541076 max      541076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541076
Ave neighs/atom = 135.269
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.932132966093, Press = 1.15744756500612
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17514.815     -17514.815     -17654.935     -17654.935      271.07249      271.07249      44130.907      44130.907     -1091.713      -1091.713     
     48000  -17515.954     -17515.954     -17659.369     -17659.369      277.44603      277.44603      44123.591      44123.591     -1210.4186     -1210.4186    
Loop time of 112.324 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.201 hours/ns, 8.903 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    | 112.17     | 112.17     | 112.17     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022646   | 0.022646   | 0.022646   |   0.0 |  0.02
Output  | 4.78e-05   | 4.78e-05   | 4.78e-05   |   0.0 |  0.00
Modify  | 0.1235     | 0.1235     | 0.1235     |   0.0 |  0.11
Other   |            | 0.01104    |            |       |  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:       540776 ave      540776 max      540776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540776
Ave neighs/atom = 135.194
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.895413317472, Press = -1.34844094898558
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17515.954     -17515.954     -17659.369     -17659.369      277.44603      277.44603      44123.591      44123.591     -1210.4186     -1210.4186    
     49000  -17518.705     -17518.705     -17658.571     -17658.571      270.57949      270.57949      44082.109      44082.109      577.79041      577.79041    
Loop time of 112.21 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.169 hours/ns, 8.912 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    | 112.05     | 112.05     | 112.05     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022602   | 0.022602   | 0.022602   |   0.0 |  0.02
Output  | 4.8741e-05 | 4.8741e-05 | 4.8741e-05 |   0.0 |  0.00
Modify  | 0.12249    | 0.12249    | 0.12249    |   0.0 |  0.11
Other   |            | 0.01121    |            |       |  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:       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.888527114461, Press = -0.534340847772056
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17518.705     -17518.705     -17658.571     -17658.571      270.57949      270.57949      44082.109      44082.109      577.79041      577.79041    
     50000  -17514.672     -17514.672     -17655.944     -17655.944      273.29966      273.29966      44105.677      44105.677     -100.23488     -100.23488    
Loop time of 112.337 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.205 hours/ns, 8.902 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    | 112.18     | 112.18     | 112.18     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022625   | 0.022625   | 0.022625   |   0.0 |  0.02
Output  | 4.797e-05  | 4.797e-05  | 4.797e-05  |   0.0 |  0.00
Modify  | 0.12264    | 0.12264    | 0.12264    |   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:           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.924185631126, Press = -0.401563312994251
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     50000  -17514.672     -17514.672     -17655.944     -17655.944      273.29966      273.29966      44105.677      44105.677     -100.23488     -100.23488    
     51000  -17516.311     -17516.311     -17659.491     -17659.491      276.99193      276.99193      44099.69       44099.69      -181.36268     -181.36268    
Loop time of 112.495 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.249 hours/ns, 8.889 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    | 112.34     | 112.34     | 112.34     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022352   | 0.022352   | 0.022352   |   0.0 |  0.02
Output  | 4.9373e-05 | 4.9373e-05 | 4.9373e-05 |   0.0 |  0.00
Modify  | 0.12338    | 0.12338    | 0.12338    |   0.0 |  0.11
Other   |            | 0.01103    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6073 ave        6073 max        6073 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540790 ave      540790 max      540790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540790
Ave neighs/atom = 135.1975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.923502671539, Press = -0.6964346100983
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -17516.311     -17516.311     -17659.491     -17659.491      276.99193      276.99193      44099.69       44099.69      -181.36268     -181.36268    
     52000  -17519.21      -17519.21      -17658.906     -17658.906      270.25049      270.25049      44072.209      44072.209      923.42915      923.42915    
Loop time of 112.163 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.156 hours/ns, 8.916 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    | 112.01     | 112.01     | 112.01     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02254    | 0.02254    | 0.02254    |   0.0 |  0.02
Output  | 4.809e-05  | 4.809e-05  | 4.809e-05  |   0.0 |  0.00
Modify  | 0.12233    | 0.12233    | 0.12233    |   0.0 |  0.11
Other   |            | 0.01103    |            |       |  0.01

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

Total # of neighbors = 540728
Ave neighs/atom = 135.182
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.922964027141, Press = 0.107602308836769
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17519.21      -17519.21      -17658.906     -17658.906      270.25049      270.25049      44072.209      44072.209      923.42915      923.42915    
     53000  -17514.232     -17514.232     -17656.759     -17656.759      275.72744      275.72744      44149.097      44149.097     -1998.6148     -1998.6148    
Loop time of 112.441 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.234 hours/ns, 8.894 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    | 112.29     | 112.29     | 112.29     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02243    | 0.02243    | 0.02243    |   0.0 |  0.02
Output  | 4.6307e-05 | 4.6307e-05 | 4.6307e-05 |   0.0 |  0.00
Modify  | 0.12264    | 0.12264    | 0.12264    |   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:           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:       540730 ave      540730 max      540730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540730
Ave neighs/atom = 135.1825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.927842484142, Press = -0.592904307117694
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17514.232     -17514.232     -17656.759     -17656.759      275.72744      275.72744      44149.097      44149.097     -1998.6148     -1998.6148    
     54000  -17517.78      -17517.78      -17659.1       -17659.1        273.39425      273.39425      44070.797      44070.797      1038.1351      1038.1351    
Loop time of 112.729 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.766 ns/day, 31.314 hours/ns, 8.871 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    | 112.57     | 112.57     | 112.57     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022494   | 0.022494   | 0.022494   |   0.0 |  0.02
Output  | 4.8851e-05 | 4.8851e-05 | 4.8851e-05 |   0.0 |  0.00
Modify  | 0.12353    | 0.12353    | 0.12353    |   0.0 |  0.11
Other   |            | 0.01106    |            |       |  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:       540640 ave      540640 max      540640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540640
Ave neighs/atom = 135.16
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.896277480509, Press = -1.21378235693303
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17517.78      -17517.78      -17659.1       -17659.1        273.39425      273.39425      44070.797      44070.797      1038.1351      1038.1351    
     55000  -17514.37      -17514.37      -17656.158     -17656.158      274.29775      274.29775      44096.206      44096.206      310.73673      310.73673    
Loop time of 112.359 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.211 hours/ns, 8.900 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    | 112.2      | 112.2      | 112.2      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022509   | 0.022509   | 0.022509   |   0.0 |  0.02
Output  | 5.0305e-05 | 5.0305e-05 | 5.0305e-05 |   0.0 |  0.00
Modify  | 0.12247    | 0.12247    | 0.12247    |   0.0 |  0.11
Other   |            | 0.0112     |            |       |  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:       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 = 272.88470746076, Press = 0.53964265426664
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     55000  -17514.37      -17514.37      -17656.158     -17656.158      274.29775      274.29775      44096.206      44096.206      310.73673      310.73673    
     56000  -17514.382     -17514.382     -17656.37      -17656.37       274.68527      274.68527      44138.932      44138.932     -1456.3339     -1456.3339    
Loop time of 112.203 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.167 hours/ns, 8.912 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    | 112.05     | 112.05     | 112.05     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022347   | 0.022347   | 0.022347   |   0.0 |  0.02
Output  | 4.8421e-05 | 4.8421e-05 | 4.8421e-05 |   0.0 |  0.00
Modify  | 0.12213    | 0.12213    | 0.12213    |   0.0 |  0.11
Other   |            | 0.0107     |            |       |  0.01

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

Total # of neighbors = 540774
Ave neighs/atom = 135.1935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.883974393924, Press = -0.981615839740299
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17514.382     -17514.382     -17656.37      -17656.37       274.68527      274.68527      44138.932      44138.932     -1456.3339     -1456.3339    
     57000  -17517.955     -17517.955     -17658.8       -17658.8        272.47382      272.47382      44077.547      44077.547      853.79342      853.79342    
Loop time of 112.841 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.766 ns/day, 31.345 hours/ns, 8.862 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    | 112.68     | 112.68     | 112.68     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022405   | 0.022405   | 0.022405   |   0.0 |  0.02
Output  | 4.7219e-05 | 4.7219e-05 | 4.7219e-05 |   0.0 |  0.00
Modify  | 0.12332    | 0.12332    | 0.12332    |   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:           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:       540510 ave      540510 max      540510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540510
Ave neighs/atom = 135.1275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.889977621226, Press = -0.639395915272348
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -17517.955     -17517.955     -17658.8       -17658.8        272.47382      272.47382      44077.547      44077.547      853.79342      853.79342    
     58000  -17514.594     -17514.594     -17657.484     -17657.484      276.42937      276.42937      44105.276      44105.276     -146.49225     -146.49225    
Loop time of 112.563 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.267 hours/ns, 8.884 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    | 112.41     | 112.41     | 112.41     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022727   | 0.022727   | 0.022727   |   0.0 |  0.02
Output  | 4.9162e-05 | 4.9162e-05 | 4.9162e-05 |   0.0 |  0.00
Modify  | 0.12243    | 0.12243    | 0.12243    |   0.0 |  0.11
Other   |            | 0.01121    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6163 ave        6163 max        6163 min
Histogram: 1 0 0 0 0 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.862997860438, Press = -0.190208449285677
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17514.594     -17514.594     -17657.484     -17657.484      276.42937      276.42937      44105.276      44105.276     -146.49225     -146.49225    
     59000  -17515.294     -17515.294     -17656.387     -17656.387      272.95338      272.95338      44109.431      44109.431     -251.46276     -251.46276    
Loop time of 112.644 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.767 ns/day, 31.290 hours/ns, 8.878 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    | 112.49     | 112.49     | 112.49     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022393   | 0.022393   | 0.022393   |   0.0 |  0.02
Output  | 5.1847e-05 | 5.1847e-05 | 5.1847e-05 |   0.0 |  0.00
Modify  | 0.12234    | 0.12234    | 0.12234    |   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:           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:       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.866071599052, Press = -0.567607887591335
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17515.294     -17515.294     -17656.387     -17656.387      272.95338      272.95338      44109.431      44109.431     -251.46276     -251.46276    
     60000  -17515.942     -17515.942     -17658.481     -17658.481      275.75087      275.75087      44079.547      44079.547      733.88815      733.88815    
Loop time of 112.916 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.765 ns/day, 31.366 hours/ns, 8.856 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    | 112.76     | 112.76     | 112.76     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02252    | 0.02252    | 0.02252    |   0.0 |  0.02
Output  | 4.2329e-05 | 4.2329e-05 | 4.2329e-05 |   0.0 |  0.00
Modify  | 0.12265    | 0.12265    | 0.12265    |   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:           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:       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.866113507296, Press = -0.210263735626909
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17515.942     -17515.942     -17658.481     -17658.481      275.75087      275.75087      44079.547      44079.547      733.88815      733.88815    
     61000  -17516.076     -17516.076     -17656.494     -17656.494      271.64667      271.64667      44142.048      44142.048     -1639.2295     -1639.2295    
Loop time of 112.163 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.156 hours/ns, 8.916 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    | 112.01     | 112.01     | 112.01     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022239   | 0.022239   | 0.022239   |   0.0 |  0.02
Output  | 4.264e-05  | 4.264e-05  | 4.264e-05  |   0.0 |  0.00
Modify  | 0.12203    | 0.12203    | 0.12203    |   0.0 |  0.11
Other   |            | 0.01047    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6067 ave        6067 max        6067 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540846 ave      540846 max      540846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540846
Ave neighs/atom = 135.2115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.884784681494, Press = -0.311385225710006
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.076     -17516.076     -17656.494     -17656.494      271.64667      271.64667      44142.048      44142.048     -1639.2295     -1639.2295    
     62000  -17515.652     -17515.652     -17657.125     -17657.125      273.68916      273.68916      44082.793      44082.793      765.54457      765.54457    
Loop time of 112.338 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.205 hours/ns, 8.902 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    | 112.18     | 112.18     | 112.18     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022384   | 0.022384   | 0.022384   |   0.0 |  0.02
Output  | 4.3652e-05 | 4.3652e-05 | 4.3652e-05 |   0.0 |  0.00
Modify  | 0.12218    | 0.12218    | 0.12218    |   0.0 |  0.11
Other   |            | 0.01067    |            |       |  0.01

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

Total # of neighbors = 540566
Ave neighs/atom = 135.1415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.869224859727, Press = -1.41499238939949
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17515.652     -17515.652     -17657.125     -17657.125      273.68916      273.68916      44082.793      44082.793      765.54457      765.54457    
     63000  -17513.849     -17513.849     -17653.859     -17653.859      270.85939      270.85939      44079.507      44079.507      1193.8889      1193.8889    
Loop time of 112.756 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.766 ns/day, 31.321 hours/ns, 8.869 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    | 112.6      | 112.6      | 112.6      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022447   | 0.022447   | 0.022447   |   0.0 |  0.02
Output  | 4.4383e-05 | 4.4383e-05 | 4.4383e-05 |   0.0 |  0.00
Modify  | 0.12299    | 0.12299    | 0.12299    |   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:           6098 ave        6098 max        6098 min
Histogram: 1 0 0 0 0 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.907461784661, Press = 0.272010517595252
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -17513.849     -17513.849     -17653.859     -17653.859      270.85939      270.85939      44079.507      44079.507      1193.8889      1193.8889    
     64000  -17518.247     -17518.247     -17659.652     -17659.652      273.5565       273.5565       44113.853      44113.853     -755.66913     -755.66913    
Loop time of 112.378 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.216 hours/ns, 8.899 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    | 112.22     | 112.22     | 112.22     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022503   | 0.022503   | 0.022503   |   0.0 |  0.02
Output  | 4.0506e-05 | 4.0506e-05 | 4.0506e-05 |   0.0 |  0.00
Modify  | 0.12225    | 0.12225    | 0.12225    |   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:           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:       540998 ave      540998 max      540998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540998
Ave neighs/atom = 135.2495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.914543708882, Press = -0.515403159353495
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17518.247     -17518.247     -17659.652     -17659.652      273.5565       273.5565       44113.853      44113.853     -755.66913     -755.66913    
     65000  -17513.855     -17513.855     -17655.437     -17655.437      273.90006      273.90006      44096.739      44096.739      359.93042      359.93042    
Loop time of 112.197 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.166 hours/ns, 8.913 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    | 112.04     | 112.04     | 112.04     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022217   | 0.022217   | 0.022217   |   0.0 |  0.02
Output  | 4.4684e-05 | 4.4684e-05 | 4.4684e-05 |   0.0 |  0.00
Modify  | 0.1225     | 0.1225     | 0.1225     |   0.0 |  0.11
Other   |            | 0.01068    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6055 ave        6055 max        6055 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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.920117826205, Press = -0.630892479456787
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -17513.855     -17513.855     -17655.437     -17655.437      273.90006      273.90006      44096.739      44096.739      359.93042      359.93042    
     66000  -17516.833     -17516.833     -17658.032     -17658.032      273.15855      273.15855      44099.825      44099.825     -40.620579     -40.620579    
Loop time of 112.892 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.765 ns/day, 31.359 hours/ns, 8.858 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    | 112.74     | 112.74     | 112.74     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0228     | 0.0228     | 0.0228     |   0.0 |  0.02
Output  | 4.1979e-05 | 4.1979e-05 | 4.1979e-05 |   0.0 |  0.00
Modify  | 0.12337    | 0.12337    | 0.12337    |   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:           6152 ave        6152 max        6152 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540942 ave      540942 max      540942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540942
Ave neighs/atom = 135.2355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.927241513668, Press = 0.0702426401712615
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     66000  -17516.833     -17516.833     -17658.032     -17658.032      273.15855      273.15855      44099.825      44099.825     -40.620579     -40.620579    
     67000  -17515.402     -17515.402     -17656.085     -17656.085      272.16096      272.16096      44129.184      44129.184     -1086.2527     -1086.2527    
Loop time of 112.323 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.201 hours/ns, 8.903 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    | 112.17     | 112.17     | 112.17     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022284   | 0.022284   | 0.022284   |   0.0 |  0.02
Output  | 4.1608e-05 | 4.1608e-05 | 4.1608e-05 |   0.0 |  0.00
Modify  | 0.1219     | 0.1219     | 0.1219     |   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:           6062 ave        6062 max        6062 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540696 ave      540696 max      540696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540696
Ave neighs/atom = 135.174
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.910331826092, Press = -0.871482662282755
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -17515.402     -17515.402     -17656.085     -17656.085      272.16096      272.16096      44129.184      44129.184     -1086.2527     -1086.2527    
     68000  -17519.755     -17519.755     -17661.222     -17661.222      273.67751      273.67751      44058.347      44058.347      1314.1847      1314.1847    
Loop time of 112.163 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.156 hours/ns, 8.916 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    | 112.01     | 112.01     | 112.01     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022436   | 0.022436   | 0.022436   |   0.0 |  0.02
Output  | 4.5966e-05 | 4.5966e-05 | 4.5966e-05 |   0.0 |  0.00
Modify  | 0.12191    | 0.12191    | 0.12191    |   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:           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:       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.895373875393, Press = -0.460538858195518
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.374 | 5.374 | 5.374 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -17519.755     -17519.755     -17661.222     -17661.222      273.67751      273.67751      44058.347      44058.347      1314.1847      1314.1847    
     69000  -17512.991     -17512.991     -17654.237     -17654.237      273.25068      273.25068      44112.745      44112.745     -198.03589     -198.03589    
Loop time of 112.715 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.767 ns/day, 31.310 hours/ns, 8.872 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    | 112.56     | 112.56     | 112.56     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022579   | 0.022579   | 0.022579   |   0.0 |  0.02
Output  | 3.9805e-05 | 3.9805e-05 | 3.9805e-05 |   0.0 |  0.00
Modify  | 0.12316    | 0.12316    | 0.12316    |   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:           6086 ave        6086 max        6086 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540932 ave      540932 max      540932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540932
Ave neighs/atom = 135.233
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.887956568759, Press = 0.344196898733598
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17512.991     -17512.991     -17654.237     -17654.237      273.25068      273.25068      44112.745      44112.745     -198.03589     -198.03589    
     70000  -17517.982     -17517.982     -17655.976     -17655.976      266.95859      266.95859      44131.414      44131.414     -1262.6548     -1262.6548    
Loop time of 112.35 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.208 hours/ns, 8.901 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    | 112.19     | 112.19     | 112.19     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022519   | 0.022519   | 0.022519   |   0.0 |  0.02
Output  | 4.0957e-05 | 4.0957e-05 | 4.0957e-05 |   0.0 |  0.00
Modify  | 0.12229    | 0.12229    | 0.12229    |   0.0 |  0.11
Other   |            | 0.01059    |            |       |  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:       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.88594957586, Press = -0.899488886014894
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.982     -17517.982     -17655.976     -17655.976      266.95859      266.95859      44131.414      44131.414     -1262.6548     -1262.6548    
     71000  -17515.349     -17515.349     -17657.788     -17657.788      275.55938      275.55938      44060.759      44060.759      1599.8882      1599.8882    
Loop time of 112.485 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.246 hours/ns, 8.890 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    | 112.33     | 112.33     | 112.33     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022467   | 0.022467   | 0.022467   |   0.0 |  0.02
Output  | 5.0054e-05 | 5.0054e-05 | 5.0054e-05 |   0.0 |  0.00
Modify  | 0.12214    | 0.12214    | 0.12214    |   0.0 |  0.11
Other   |            | 0.01067    |            |       |  0.01

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

Total # of neighbors = 540820
Ave neighs/atom = 135.205
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.883839576077, Press = -0.48470153211576
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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.349     -17515.349     -17657.788     -17657.788      275.55938      275.55938      44060.759      44060.759      1599.8882      1599.8882    
     72000  -17517.36      -17517.36      -17658.524     -17658.524      273.09123      273.09123      44126.422      44126.422     -1231.4559     -1231.4559    
Loop time of 112.891 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.765 ns/day, 31.359 hours/ns, 8.858 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    | 112.73     | 112.73     | 112.73     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02267    | 0.02267    | 0.02267    |   0.0 |  0.02
Output  | 4.3832e-05 | 4.3832e-05 | 4.3832e-05 |   0.0 |  0.00
Modify  | 0.1226     | 0.1226     | 0.1226     |   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:           6162 ave        6162 max        6162 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       541012 ave      541012 max      541012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541012
Ave neighs/atom = 135.253
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.895916619115, Press = 0.326064576179557
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17517.36      -17517.36      -17658.524     -17658.524      273.09123      273.09123      44126.422      44126.422     -1231.4559     -1231.4559    
     73000  -17515.646     -17515.646     -17656.265     -17656.265      272.0358       272.0358       44120.777      44120.777     -791.08891     -791.08891    
Loop time of 111.867 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.772 ns/day, 31.074 hours/ns, 8.939 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    | 111.71     | 111.71     | 111.71     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022274   | 0.022274   | 0.022274   |   0.0 |  0.02
Output  | 4.231e-05  | 4.231e-05  | 4.231e-05  |   0.0 |  0.00
Modify  | 0.12175    | 0.12175    | 0.12175    |   0.0 |  0.11
Other   |            | 0.01069    |            |       |  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:       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.883128666381, Press = -1.46188098239485
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17515.646     -17515.646     -17656.265     -17656.265      272.0358       272.0358       44120.777      44120.777     -791.08891     -791.08891    
     74000  -17513.614     -17513.614     -17656.393     -17656.393      276.21583      276.21583      44068.103      44068.103      1478.8479      1478.8479    
Loop time of 112.459 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.239 hours/ns, 8.892 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    | 112.3      | 112.3      | 112.3      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022577   | 0.022577   | 0.022577   |   0.0 |  0.02
Output  | 4.2079e-05 | 4.2079e-05 | 4.2079e-05 |   0.0 |  0.00
Modify  | 0.12251    | 0.12251    | 0.12251    |   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:           6148 ave        6148 max        6148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540810 ave      540810 max      540810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540810
Ave neighs/atom = 135.2025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.87584938529, Press = -0.120942735039532
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17513.614     -17513.614     -17656.393     -17656.393      276.21583      276.21583      44068.103      44068.103      1478.8479      1478.8479    
     75000  -17521.852     -17521.852     -17661.689     -17661.689      270.52489      270.52489      44109.148      44109.148     -835.53037     -835.53037    
Loop time of 112.109 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.771 ns/day, 31.141 hours/ns, 8.920 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    | 111.95     | 111.95     | 111.95     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022562   | 0.022562   | 0.022562   |   0.0 |  0.02
Output  | 4.1969e-05 | 4.1969e-05 | 4.1969e-05 |   0.0 |  0.00
Modify  | 0.12236    | 0.12236    | 0.12236    |   0.0 |  0.11
Other   |            | 0.01071    |            |       |  0.01

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

Total # of neighbors = 541038
Ave neighs/atom = 135.2595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.861611378366, Press = -0.11321760599448
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17521.852     -17521.852     -17661.689     -17661.689      270.52489      270.52489      44109.148      44109.148     -835.53037     -835.53037    
     76000  -17515.225     -17515.225     -17656.522     -17656.522      273.3488       273.3488       44101.021      44101.021      109.86711      109.86711    
Loop time of 111.94 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.772 ns/day, 31.095 hours/ns, 8.933 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    | 111.79     | 111.79     | 111.79     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022442   | 0.022442   | 0.022442   |   0.0 |  0.02
Output  | 4.2309e-05 | 4.2309e-05 | 4.2309e-05 |   0.0 |  0.00
Modify  | 0.1219     | 0.1219     | 0.1219     |   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:           6147 ave        6147 max        6147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540614 ave      540614 max      540614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540614
Ave neighs/atom = 135.1535
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.856267637753, Press = -0.640387803893661
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17515.225     -17515.225     -17656.522     -17656.522      273.3488       273.3488       44101.021      44101.021      109.86711      109.86711    
     77000  -17518.516     -17518.516     -17656.672     -17656.672      267.27266      267.27266      44069.634      44069.634      1320.6562      1320.6562    
Loop time of 112.414 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.226 hours/ns, 8.896 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    | 112.26     | 112.26     | 112.26     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022392   | 0.022392   | 0.022392   |   0.0 |  0.02
Output  | 4.5345e-05 | 4.5345e-05 | 4.5345e-05 |   0.0 |  0.00
Modify  | 0.12211    | 0.12211    | 0.12211    |   0.0 |  0.11
Other   |            | 0.01048    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6054 ave        6054 max        6054 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540718 ave      540718 max      540718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540718
Ave neighs/atom = 135.1795
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.836872616833, Press = -0.0567228028366768
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17518.516     -17518.516     -17656.672     -17656.672      267.27266      267.27266      44069.634      44069.634      1320.6562      1320.6562    
     78000  -17512.249     -17512.249     -17655.361     -17655.361      276.85971      276.85971      44161.114      44161.114     -2281.8964     -2281.8964    
Loop time of 112.177 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.160 hours/ns, 8.914 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    | 112.02     | 112.02     | 112.02     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022691   | 0.022691   | 0.022691   |   0.0 |  0.02
Output  | 4.3331e-05 | 4.3331e-05 | 4.3331e-05 |   0.0 |  0.00
Modify  | 0.12192    | 0.12192    | 0.12192    |   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:           6194 ave        6194 max        6194 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540844 ave      540844 max      540844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540844
Ave neighs/atom = 135.211
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.839022136408, Press = -0.0257311191465009
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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  -17512.249     -17512.249     -17655.361     -17655.361      276.85971      276.85971      44161.114      44161.114     -2281.8964     -2281.8964    
     79000  -17516.591     -17516.591     -17657.958     -17657.958      273.48257      273.48257      44085.268      44085.268      506.84135      506.84135    
Loop time of 111.765 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.773 ns/day, 31.046 hours/ns, 8.947 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    | 111.61     | 111.61     | 111.61     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022281   | 0.022281   | 0.022281   |   0.0 |  0.02
Output  | 4.2099e-05 | 4.2099e-05 | 4.2099e-05 |   0.0 |  0.00
Modify  | 0.12175    | 0.12175    | 0.12175    |   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:           6098 ave        6098 max        6098 min
Histogram: 1 0 0 0 0 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.860847492416, Press = -1.24090091118997
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     79000  -17516.591     -17516.591     -17657.958     -17657.958      273.48257      273.48257      44085.268      44085.268      506.84135      506.84135    
     80000  -17511.752     -17511.752     -17655.648     -17655.648      278.37734      278.37734      44073.899      44073.899      1317.8519      1317.8519    
Loop time of 112.309 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.197 hours/ns, 8.904 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    | 112.15     | 112.15     | 112.15     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022597   | 0.022597   | 0.022597   |   0.0 |  0.02
Output  | 4.1388e-05 | 4.1388e-05 | 4.1388e-05 |   0.0 |  0.00
Modify  | 0.12252    | 0.12252    | 0.12252    |   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:           6167 ave        6167 max        6167 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540992 ave      540992 max      540992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540992
Ave neighs/atom = 135.248
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.875893379768, Press = 0.28035233728788
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     80000  -17511.752     -17511.752     -17655.648     -17655.648      278.37734      278.37734      44073.899      44073.899      1317.8519      1317.8519    
     81000  -17516.864     -17516.864     -17655.796     -17655.796      268.77312      268.77312      44123.969      44123.969     -876.03454     -876.03454    
Loop time of 112.269 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.186 hours/ns, 8.907 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    | 112.11     | 112.11     | 112.11     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022455   | 0.022455   | 0.022455   |   0.0 |  0.02
Output  | 4.1679e-05 | 4.1679e-05 | 4.1679e-05 |   0.0 |  0.00
Modify  | 0.12191    | 0.12191    | 0.12191    |   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:           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:       541008 ave      541008 max      541008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541008
Ave neighs/atom = 135.252
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.883422493512, Press = -0.289831442399747
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     81000  -17516.864     -17516.864     -17655.796     -17655.796      268.77312      268.77312      44123.969      44123.969     -876.03454     -876.03454    
     82000  -17514.431     -17514.431     -17656.405     -17656.405      274.65893      274.65893      44089.86       44089.86       569.56585      569.56585    
Loop time of 111.702 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.773 ns/day, 31.028 hours/ns, 8.952 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    | 111.55     | 111.55     | 111.55     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022299   | 0.022299   | 0.022299   |   0.0 |  0.02
Output  | 4.5075e-05 | 4.5075e-05 | 4.5075e-05 |   0.0 |  0.00
Modify  | 0.12177    | 0.12177    | 0.12177    |   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:           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:       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.872713442836, Press = -0.545168593594549
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     82000  -17514.431     -17514.431     -17656.405     -17656.405      274.65893      274.65893      44089.86       44089.86       569.56585      569.56585    
     83000  -17512.084     -17512.084     -17654.719     -17654.719      275.9363       275.9363       44089.875      44089.875      669.38412      669.38412    
Loop time of 112.491 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.247 hours/ns, 8.890 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    | 112.33     | 112.33     | 112.33     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022515   | 0.022515   | 0.022515   |   0.0 |  0.02
Output  | 4.9022e-05 | 4.9022e-05 | 4.9022e-05 |   0.0 |  0.00
Modify  | 0.12314    | 0.12314    | 0.12314    |   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:           6096 ave        6096 max        6096 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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.868910739498, Press = 0.150461149035836
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     83000  -17512.084     -17512.084     -17654.719     -17654.719      275.9363       275.9363       44089.875      44089.875      669.38412      669.38412    
     84000  -17516.442     -17516.442     -17660.556     -17660.556      278.79782      278.79782      44186.16       44186.16      -3824.8651     -3824.8651    
Loop time of 112.512 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.253 hours/ns, 8.888 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    | 112.36     | 112.36     | 112.36     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022566   | 0.022566   | 0.022566   |   0.0 |  0.02
Output  | 5.1336e-05 | 5.1336e-05 | 5.1336e-05 |   0.0 |  0.00
Modify  | 0.12283    | 0.12283    | 0.12283    |   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:           6134 ave        6134 max        6134 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540920 ave      540920 max      540920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540920
Ave neighs/atom = 135.23
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.881790780742, Press = -0.545784326266185
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     84000  -17516.442     -17516.442     -17660.556     -17660.556      278.79782      278.79782      44186.16       44186.16      -3824.8651     -3824.8651    
     85000  -17515.328     -17515.328     -17657.453     -17657.453      274.94959      274.94959      44064.874      44064.874      1518.0649      1518.0649    
Loop time of 112.058 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.771 ns/day, 31.127 hours/ns, 8.924 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    | 111.9      | 111.9      | 111.9      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02222    | 0.02222    | 0.02222    |   0.0 |  0.02
Output  | 5.0064e-05 | 5.0064e-05 | 5.0064e-05 |   0.0 |  0.00
Modify  | 0.12233    | 0.12233    | 0.12233    |   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:           6046 ave        6046 max        6046 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540344 ave      540344 max      540344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540344
Ave neighs/atom = 135.086
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.907836620753, Press = -0.804855095660338
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     85000  -17515.328     -17515.328     -17657.453     -17657.453      274.94959      274.94959      44064.874      44064.874      1518.0649      1518.0649    
     86000  -17517.444     -17517.444     -17657.514     -17657.514      270.97635      270.97635      44093.304      44093.304      263.58854      263.58854    
Loop time of 112.726 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.766 ns/day, 31.313 hours/ns, 8.871 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    | 112.57     | 112.57     | 112.57     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022685   | 0.022685   | 0.022685   |   0.0 |  0.02
Output  | 4.4263e-05 | 4.4263e-05 | 4.4263e-05 |   0.0 |  0.00
Modify  | 0.1227     | 0.1227     | 0.1227     |   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:           6163 ave        6163 max        6163 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540852 ave      540852 max      540852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540852
Ave neighs/atom = 135.213
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.911864763091, Press = 0.120308948648982
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     86000  -17517.444     -17517.444     -17657.514     -17657.514      270.97635      270.97635      44093.304      44093.304      263.58854      263.58854    
     87000  -17510.519     -17510.519     -17654.629     -17654.629      278.79193      278.79193      44135.435      44135.435     -1051.9661     -1051.9661    
Loop time of 112.244 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.179 hours/ns, 8.909 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    | 112.09     | 112.09     | 112.09     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022489   | 0.022489   | 0.022489   |   0.0 |  0.02
Output  | 4.762e-05  | 4.762e-05  | 4.762e-05  |   0.0 |  0.00
Modify  | 0.12255    | 0.12255    | 0.12255    |   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:           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:       540784 ave      540784 max      540784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540784
Ave neighs/atom = 135.196
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.925630150956, Press = -0.478338983357883
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     87000  -17510.519     -17510.519     -17654.629     -17654.629      278.79193      278.79193      44135.435      44135.435     -1051.9661     -1051.9661    
     88000  -17515.263     -17515.263     -17656.311     -17656.311      272.86694      272.86694      44072.089      44072.089      1197.9753      1197.9753    
Loop time of 111.869 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.772 ns/day, 31.075 hours/ns, 8.939 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    | 111.71     | 111.71     | 111.71     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022256   | 0.022256   | 0.022256   |   0.0 |  0.02
Output  | 4.3332e-05 | 4.3332e-05 | 4.3332e-05 |   0.0 |  0.00
Modify  | 0.12201    | 0.12201    | 0.12201    |   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:           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:       540580 ave      540580 max      540580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540580
Ave neighs/atom = 135.145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.936696239333, Press = -0.409639305455972
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     88000  -17515.263     -17515.263     -17656.311     -17656.311      272.86694      272.86694      44072.089      44072.089      1197.9753      1197.9753    
     89000  -17520.681     -17520.681     -17659.3       -17659.3        268.16826      268.16826      44101.717      44101.717     -327.47393     -327.47393    
Loop time of 112.565 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.268 hours/ns, 8.884 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    | 112.41     | 112.41     | 112.41     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022738   | 0.022738   | 0.022738   |   0.0 |  0.02
Output  | 4.4543e-05 | 4.4543e-05 | 4.4543e-05 |   0.0 |  0.00
Modify  | 0.12333    | 0.12333    | 0.12333    |   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:           6172 ave        6172 max        6172 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540942 ave      540942 max      540942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540942
Ave neighs/atom = 135.2355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.934572017947, Press = 0.555558301322407
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     89000  -17520.681     -17520.681     -17659.3       -17659.3        268.16826      268.16826      44101.717      44101.717     -327.47393     -327.47393    
     90000  -17514.521     -17514.521     -17655.976     -17655.976      273.65452      273.65452      44171.43       44171.43      -2799.7784     -2799.7784    
Loop time of 112.225 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.174 hours/ns, 8.911 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    | 112.07     | 112.07     | 112.07     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022718   | 0.022718   | 0.022718   |   0.0 |  0.02
Output  | 4.3602e-05 | 4.3602e-05 | 4.3602e-05 |   0.0 |  0.00
Modify  | 0.1224     | 0.1224     | 0.1224     |   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:           6103 ave        6103 max        6103 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540676 ave      540676 max      540676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540676
Ave neighs/atom = 135.169
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.919780082188, Press = -1.19295139064504
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     90000  -17514.521     -17514.521     -17655.976     -17655.976      273.65452      273.65452      44171.43       44171.43      -2799.7784     -2799.7784    
     91000  -17517.37      -17517.37      -17656.832     -17656.832      269.7998       269.7998       44061.287      44061.287      1691.1669      1691.1669    
Loop time of 112.288 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.191 hours/ns, 8.906 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    | 112.13     | 112.13     | 112.13     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022439   | 0.022439   | 0.022439   |   0.0 |  0.02
Output  | 4.4393e-05 | 4.4393e-05 | 4.4393e-05 |   0.0 |  0.00
Modify  | 0.12241    | 0.12241    | 0.12241    |   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:           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:       540460 ave      540460 max      540460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540460
Ave neighs/atom = 135.115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.915714120028, Press = -0.165999562752953
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     91000  -17517.37      -17517.37      -17656.832     -17656.832      269.7998       269.7998       44061.287      44061.287      1691.1669      1691.1669    
     92000  -17515.904     -17515.904     -17655.747     -17655.747      270.53479      270.53479      44116.558      44116.558     -501.79943     -501.79943    
Loop time of 112.758 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.766 ns/day, 31.322 hours/ns, 8.869 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    | 112.6      | 112.6      | 112.6      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022452   | 0.022452   | 0.022452   |   0.0 |  0.02
Output  | 4.9994e-05 | 4.9994e-05 | 4.9994e-05 |   0.0 |  0.00
Modify  | 0.1232     | 0.1232     | 0.1232     |   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:           6115 ave        6115 max        6115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540898 ave      540898 max      540898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540898
Ave neighs/atom = 135.2245
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.921358653576, Press = 0.0192029929905052
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     92000  -17515.904     -17515.904     -17655.747     -17655.747      270.53479      270.53479      44116.558      44116.558     -501.79943     -501.79943    
     93000  -17517.195     -17517.195     -17656.731     -17656.731      269.94169      269.94169      44103.374      44103.374     -137.04166     -137.04166    
Loop time of 112.332 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.203 hours/ns, 8.902 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    | 112.18     | 112.18     | 112.18     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022524   | 0.022524   | 0.022524   |   0.0 |  0.02
Output  | 7.0823e-05 | 7.0823e-05 | 7.0823e-05 |   0.0 |  0.00
Modify  | 0.12241    | 0.12241    | 0.12241    |   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:           6109 ave        6109 max        6109 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540642 ave      540642 max      540642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540642
Ave neighs/atom = 135.1605
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.911928115536, Press = -0.439735601673271
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     93000  -17517.195     -17517.195     -17656.731     -17656.731      269.94169      269.94169      44103.374      44103.374     -137.04166     -137.04166    
     94000  -17517.519     -17517.519     -17656.429     -17656.429      268.72997      268.72997      44067.999      44067.999      1405.5958      1405.5958    
Loop time of 112.539 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.261 hours/ns, 8.886 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    | 112.38     | 112.38     | 112.38     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022557   | 0.022557   | 0.022557   |   0.0 |  0.02
Output  | 5.0515e-05 | 5.0515e-05 | 5.0515e-05 |   0.0 |  0.00
Modify  | 0.12284    | 0.12284    | 0.12284    |   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:           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:       540710 ave      540710 max      540710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540710
Ave neighs/atom = 135.1775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.905639571014, Press = -0.0683127766172873
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     94000  -17517.519     -17517.519     -17656.429     -17656.429      268.72997      268.72997      44067.999      44067.999      1405.5958      1405.5958    
     95000  -17515.306     -17515.306     -17657.218     -17657.218      274.53875      274.53875      44160.49       44160.49      -2496.9323     -2496.9323    
Loop time of 112.294 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.193 hours/ns, 8.905 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    | 112.14     | 112.14     | 112.14     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022734   | 0.022734   | 0.022734   |   0.0 |  0.02
Output  | 5.1006e-05 | 5.1006e-05 | 5.1006e-05 |   0.0 |  0.00
Modify  | 0.12253    | 0.12253    | 0.12253    |   0.0 |  0.11
Other   |            | 0.01077    |            |       |  0.01

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

Total # of neighbors = 540872
Ave neighs/atom = 135.218
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.886248527908, Press = -0.0879783103282072
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     95000  -17515.306     -17515.306     -17657.218     -17657.218      274.53875      274.53875      44160.49       44160.49      -2496.9323     -2496.9323    
     96000  -17517.904     -17517.904     -17657.631     -17657.631      270.31087      270.31087      44079.462      44079.462      808.98744      808.98744    
Loop time of 112.283 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.190 hours/ns, 8.906 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    | 112.13     | 112.13     | 112.13     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022419   | 0.022419   | 0.022419   |   0.0 |  0.02
Output  | 5.2689e-05 | 5.2689e-05 | 5.2689e-05 |   0.0 |  0.00
Modify  | 0.12338    | 0.12338    | 0.12338    |   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:           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:       540604 ave      540604 max      540604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540604
Ave neighs/atom = 135.151
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.886756068387, Press = -0.741435037741966
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     96000  -17517.904     -17517.904     -17657.631     -17657.631      270.31087      270.31087      44079.462      44079.462      808.98744      808.98744    
     97000  -17515.456     -17515.456     -17656.71      -17656.71       273.2655       273.2655       44075.942      44075.942      1149.2607      1149.2607    
Loop time of 112.627 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.767 ns/day, 31.285 hours/ns, 8.879 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    | 112.47     | 112.47     | 112.47     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022631   | 0.022631   | 0.022631   |   0.0 |  0.02
Output  | 5.2609e-05 | 5.2609e-05 | 5.2609e-05 |   0.0 |  0.00
Modify  | 0.12263    | 0.12263    | 0.12263    |   0.0 |  0.11
Other   |            | 0.01072    |            |       |  0.01

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

Total # of neighbors = 540936
Ave neighs/atom = 135.234
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.908969437142, Press = 0.152694838171857
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     97000  -17515.456     -17515.456     -17656.71      -17656.71       273.2655       273.2655       44075.942      44075.942      1149.2607      1149.2607    
     98000  -17512.672     -17512.672     -17653.892     -17653.892      273.20077      273.20077      44139.514      44139.514     -1233.8662     -1233.8662    
Loop time of 112.441 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.768 ns/day, 31.234 hours/ns, 8.894 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    | 112.29     | 112.29     | 112.29     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02236    | 0.02236    | 0.02236    |   0.0 |  0.02
Output  | 4.786e-05  | 4.786e-05  | 4.786e-05  |   0.0 |  0.00
Modify  | 0.12209    | 0.12209    | 0.12209    |   0.0 |  0.11
Other   |            | 0.01071    |            |       |  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:       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.921598264007, Press = -0.233565648095926
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     98000  -17512.672     -17512.672     -17653.892     -17653.892      273.20077      273.20077      44139.514      44139.514     -1233.8662     -1233.8662    
     99000  -17518.411     -17518.411     -17657.576     -17657.576      269.22329      269.22329      44087.281      44087.281      503.69921      503.69921    
Loop time of 112.728 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.766 ns/day, 31.313 hours/ns, 8.871 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    | 112.57     | 112.57     | 112.57     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023003   | 0.023003   | 0.023003   |   0.0 |  0.02
Output  | 4.8761e-05 | 4.8761e-05 | 4.8761e-05 |   0.0 |  0.00
Modify  | 0.12288    | 0.12288    | 0.12288    |   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:           6210 ave        6210 max        6210 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540702 ave      540702 max      540702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540702
Ave neighs/atom = 135.1755
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.933456200279, Press = -0.357813201270386
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
     99000  -17518.411     -17518.411     -17657.576     -17657.576      269.22329      269.22329      44087.281      44087.281      503.69921      503.69921    
    100000  -17519.329     -17519.329     -17660.091     -17660.091      272.31463      272.31463      44096.601      44096.601     -122.73685     -122.73685    
Loop time of 112.671 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.767 ns/day, 31.298 hours/ns, 8.875 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    | 112.51     | 112.51     | 112.51     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022577   | 0.022577   | 0.022577   |   0.0 |  0.02
Output  | 5.2319e-05 | 5.2319e-05 | 5.2319e-05 |   0.0 |  0.00
Modify  | 0.1231     | 0.1231     | 0.1231     |   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:           6096 ave        6096 max        6096 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 272.933762518574, Press = -0.137029124779692
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
    100000  -17519.329     -17519.329     -17660.091     -17660.091      272.31463      272.31463      44096.601      44096.601     -122.73685     -122.73685    
    101000  -17514.105     -17514.105     -17656.223     -17656.223      274.9369       274.9369       44109.253      44109.253     -213.46585     -213.46585    
Loop time of 112.372 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.214 hours/ns, 8.899 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    | 112.22     | 112.22     | 112.22     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022671   | 0.022671   | 0.022671   |   0.0 |  0.02
Output  | 5.834e-05  | 5.834e-05  | 5.834e-05  |   0.0 |  0.00
Modify  | 0.12308    | 0.12308    | 0.12308    |   0.0 |  0.11
Other   |            | 0.01078    |            |       |  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:       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.921801186789, Press = -0.223686964741715
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
    101000  -17514.105     -17514.105     -17656.223     -17656.223      274.9369       274.9369       44109.253      44109.253     -213.46585     -213.46585    
    102000  -17513.828     -17513.828     -17656.327     -17656.327      275.67451      275.67451      44093.137      44093.137      351.50913      351.50913    
Loop time of 112.21 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.169 hours/ns, 8.912 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    | 112.05     | 112.05     | 112.05     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022268   | 0.022268   | 0.022268   |   0.0 |  0.02
Output  | 5.325e-05  | 5.325e-05  | 5.325e-05  |   0.0 |  0.00
Modify  | 0.12246    | 0.12246    | 0.12246    |   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:           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:       540724 ave      540724 max      540724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540724
Ave neighs/atom = 135.181
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.932104819087, Press = -0.20758545690356
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
    102000  -17513.828     -17513.828     -17656.327     -17656.327      275.67451      275.67451      44093.137      44093.137      351.50913      351.50913    
    103000  -17513.716     -17513.716     -17658.314     -17658.314      279.73594      279.73594      44119.474      44119.474     -810.39002     -810.39002    
Loop time of 112.891 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.765 ns/day, 31.359 hours/ns, 8.858 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    | 112.73     | 112.73     | 112.73     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022798   | 0.022798   | 0.022798   |   0.0 |  0.02
Output  | 5.1397e-05 | 5.1397e-05 | 5.1397e-05 |   0.0 |  0.00
Modify  | 0.12319    | 0.12319    | 0.12319    |   0.0 |  0.11
Other   |            | 0.01078    |            |       |  0.01

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

Total # of neighbors = 540908
Ave neighs/atom = 135.227
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.930486147198, Press = 0.0590209813026848
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
    103000  -17513.716     -17513.716     -17658.314     -17658.314      279.73594      279.73594      44119.474      44119.474     -810.39002     -810.39002    
    104000  -17513.575     -17513.575     -17655.174     -17655.174      273.93367      273.93367      44117.453      44117.453     -513.07076     -513.07076    
Loop time of 112.32 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.769 ns/day, 31.200 hours/ns, 8.903 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    | 112.16     | 112.16     | 112.16     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022366   | 0.022366   | 0.022366   |   0.0 |  0.02
Output  | 6.1756e-05 | 6.1756e-05 | 6.1756e-05 |   0.0 |  0.00
Modify  | 0.12221    | 0.12221    | 0.12221    |   0.0 |  0.11
Other   |            | 0.0107     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6075 ave        6075 max        6075 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       540722 ave      540722 max      540722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540722
Ave neighs/atom = 135.1805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.952054635672, Press = -0.642508166935256
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 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   
    104000  -17513.575     -17513.575     -17655.174     -17655.174      273.93367      273.93367      44117.453      44117.453     -513.07076     -513.07076    
    105000  -17516.586     -17516.586     -17658.148     -17658.148      273.8611       273.8611       44054.147      44054.147      1886.6776      1886.6776    
Loop time of 112.165 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.157 hours/ns, 8.915 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    | 112.01     | 112.01     | 112.01     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022675   | 0.022675   | 0.022675   |   0.0 |  0.02
Output  | 5.6697e-05 | 5.6697e-05 | 5.6697e-05 |   0.0 |  0.00
Modify  | 0.12283    | 0.12283    | 0.12283    |   0.0 |  0.11
Other   |            | 0.01078    |            |       |  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:       540758 ave      540758 max      540758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540758
Ave neighs/atom = 135.1895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
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.6825914428

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0