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

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

kim_interactions Al

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

kim interactions Al
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimKimJung_2017_NiAlTi__MO_478967255435_002
pair_coeff * * Al
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 26.981538

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66167.2528701086 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

# print to logfile every 1000 timesteps
thermo_style  custom step etotal v_etotal_metal pe v_pe_metal               temp v_T_metal vol v_V_metal press v_P_metal
thermo        1000

# Run a simulation for at most 2000*1000 timesteps. At each 1000th time step, check
# whether the temperature and pressure have converged. If yes, break.
label top
variable a loop 2000
run 1000

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

Your simulation uses code contributions which should be cited:

- OpenKIM: https://doi.org/10.1007/s11837-011-0102-6

@Article{tadmor:elliott:2011,
 author = {E. B. Tadmor and R. S. Elliott and J. P. Sethna and R. E. Miller and C. A. Becker},
 title = {The potential of atomistic simulations and the {K}nowledgebase of {I}nteratomic {M}odels},
 journal = {{JOM}},
 year =    2011,
 volume =  63,
 number =  17,
 pages =   {17},
 doi =     {10.1007/s11837-011-0102-6}
}

- OpenKIM potential: https://openkim.org/cite/MO_478967255435_002#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13267.791     -13267.791     -13440         -13440          333.15         333.15         66167.253      66167.253      2779.8962      2779.8962    
      1000  -13075.359     -13075.359     -13255.181     -13255.181      347.8789       347.8789       67709.656      67709.656     -1536.5078     -1536.5078    
Loop time of 67.0908 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.288 ns/day, 18.636 hours/ns, 14.905 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 66.938     | 66.938     | 66.938     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021871   | 0.021871   | 0.021871   |   0.0 |  0.03
Output  | 0.00016747 | 0.00016747 | 0.00016747 |   0.0 |  0.00
Modify  | 0.1195     | 0.1195     | 0.1195     |   0.0 |  0.18
Other   |            | 0.01109    |            |       |  0.02

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

Total # of neighbors = 312000
Ave neighs/atom = 78
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13075.359     -13075.359     -13255.181     -13255.181      347.8789       347.8789       67709.656      67709.656     -1536.5078     -1536.5078    
      2000  -13094.787     -13094.787     -13266.546     -13266.546      332.27822      332.27822      67471.611      67471.611      217.77104      217.77104    
Loop time of 76.13 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.135 ns/day, 21.147 hours/ns, 13.135 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 75.978     | 75.978     | 75.978     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022016   | 0.022016   | 0.022016   |   0.0 |  0.03
Output  | 5.8981e-05 | 5.8981e-05 | 5.8981e-05 |   0.0 |  0.00
Modify  | 0.11907    | 0.11907    | 0.11907    |   0.0 |  0.16
Other   |            | 0.0105     |            |       |  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:       322426 ave      322426 max      322426 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322426
Ave neighs/atom = 80.6065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13094.787     -13094.787     -13266.546     -13266.546      332.27822      332.27822      67471.611      67471.611      217.77104      217.77104    
      3000  -13081.184     -13081.184     -13252.35      -13252.35       331.13171      331.13171      67555.778      67555.778      226.53217      226.53217    
Loop time of 76.5486 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.129 ns/day, 21.263 hours/ns, 13.064 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    | 76.397     | 76.397     | 76.397     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022299   | 0.022299   | 0.022299   |   0.0 |  0.03
Output  | 5.9382e-05 | 5.9382e-05 | 5.9382e-05 |   0.0 |  0.00
Modify  | 0.11891    | 0.11891    | 0.11891    |   0.0 |  0.16
Other   |            | 0.01045    |            |       |  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:       323082 ave      323082 max      323082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323082
Ave neighs/atom = 80.7705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13081.184     -13081.184     -13252.35      -13252.35       331.13171      331.13171      67555.778      67555.778      226.53217      226.53217    
      4000  -13091.557     -13091.557     -13261.588     -13261.588      328.9354       328.9354       67536.578      67536.578     -235.07983     -235.07983    
Loop time of 76.5834 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.128 ns/day, 21.273 hours/ns, 13.058 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    | 76.432     | 76.432     | 76.432     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022073   | 0.022073   | 0.022073   |   0.0 |  0.03
Output  | 6.9831e-05 | 6.9831e-05 | 6.9831e-05 |   0.0 |  0.00
Modify  | 0.11897    | 0.11897    | 0.11897    |   0.0 |  0.16
Other   |            | 0.01042    |            |       |  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:       323082 ave      323082 max      323082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323082
Ave neighs/atom = 80.7705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13091.557     -13091.557     -13261.588     -13261.588      328.9354       328.9354       67536.578      67536.578     -235.07983     -235.07983    
      5000  -13085.454     -13085.454     -13259.453     -13259.453      336.61235      336.61235      67526.099      67526.099      52.386878      52.386878    
Loop time of 76.7821 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.125 ns/day, 21.328 hours/ns, 13.024 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    | 76.63      | 76.63      | 76.63      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022015   | 0.022015   | 0.022015   |   0.0 |  0.03
Output  | 4.4053e-05 | 4.4053e-05 | 4.4053e-05 |   0.0 |  0.00
Modify  | 0.11927    | 0.11927    | 0.11927    |   0.0 |  0.16
Other   |            | 0.01043    |            |       |  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:       322962 ave      322962 max      322962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322962
Ave neighs/atom = 80.7405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 338.060472169952, Press = -157.457238124431
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13085.454     -13085.454     -13259.453     -13259.453      336.61235      336.61235      67526.099      67526.099      52.386878      52.386878    
      6000  -13087.075     -13087.075     -13259.941     -13259.941      334.42214      334.42214      67568.171      67568.171     -435.7594      -435.7594     
Loop time of 76.7163 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.126 ns/day, 21.310 hours/ns, 13.035 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    | 76.561     | 76.561     | 76.561     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022178   | 0.022178   | 0.022178   |   0.0 |  0.03
Output  | 4.6899e-05 | 4.6899e-05 | 4.6899e-05 |   0.0 |  0.00
Modify  | 0.12292    | 0.12292    | 0.12292    |   0.0 |  0.16
Other   |            | 0.01046    |            |       |  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:       323048 ave      323048 max      323048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323048
Ave neighs/atom = 80.762
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.721317534723, Press = 15.014987834536
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13087.075     -13087.075     -13259.941     -13259.941      334.42214      334.42214      67568.171      67568.171     -435.7594      -435.7594     
      7000  -13088.344     -13088.344     -13260.093     -13260.093      332.25964      332.25964      67444.71       67444.71       906.03212      906.03212    
Loop time of 76.7154 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.126 ns/day, 21.310 hours/ns, 13.035 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    | 76.56      | 76.56      | 76.56      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021872   | 0.021872   | 0.021872   |   0.0 |  0.03
Output  | 4.5105e-05 | 4.5105e-05 | 4.5105e-05 |   0.0 |  0.00
Modify  | 0.12292    | 0.12292    | 0.12292    |   0.0 |  0.16
Other   |            | 0.01048    |            |       |  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:       322794 ave      322794 max      322794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322794
Ave neighs/atom = 80.6985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.207552201388, Press = -19.9539220933045
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13088.344     -13088.344     -13260.093     -13260.093      332.25964      332.25964      67444.71       67444.71       906.03212      906.03212    
      8000  -13087.19      -13087.19      -13255.991     -13255.991      326.55662      326.55662      67668.77       67668.77      -1396.3823     -1396.3823    
Loop time of 76.9279 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.123 ns/day, 21.369 hours/ns, 12.999 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    | 76.773     | 76.773     | 76.773     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021827   | 0.021827   | 0.021827   |   0.0 |  0.03
Output  | 5.2519e-05 | 5.2519e-05 | 5.2519e-05 |   0.0 |  0.00
Modify  | 0.12282    | 0.12282    | 0.12282    |   0.0 |  0.16
Other   |            | 0.01044    |            |       |  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:       323088 ave      323088 max      323088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323088
Ave neighs/atom = 80.772
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.928826348947, Press = 6.32044947681683
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13087.19      -13087.19      -13255.991     -13255.991      326.55662      326.55662      67668.77       67668.77      -1396.3823     -1396.3823    
      9000  -13091.307     -13091.307     -13260.989     -13260.989      328.26263      328.26263      67431.108      67431.108      935.11371      935.11371    
Loop time of 76.672 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.127 ns/day, 21.298 hours/ns, 13.043 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    | 76.517     | 76.517     | 76.517     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022069   | 0.022069   | 0.022069   |   0.0 |  0.03
Output  | 4.251e-05  | 4.251e-05  | 4.251e-05  |   0.0 |  0.00
Modify  | 0.12282    | 0.12282    | 0.12282    |   0.0 |  0.16
Other   |            | 0.01045    |            |       |  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:       322718 ave      322718 max      322718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322718
Ave neighs/atom = 80.6795
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.689062120914, Press = -1.15740381504691
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13091.307     -13091.307     -13260.989     -13260.989      328.26263      328.26263      67431.108      67431.108      935.11371      935.11371    
     10000  -13087.459     -13087.459     -13260.117     -13260.117      334.01832      334.01832      67587.696      67587.696     -748.50425     -748.50425    
Loop time of 77.0364 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.122 ns/day, 21.399 hours/ns, 12.981 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    | 76.881     | 76.881     | 76.881     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022022   | 0.022022   | 0.022022   |   0.0 |  0.03
Output  | 4.4684e-05 | 4.4684e-05 | 4.4684e-05 |   0.0 |  0.00
Modify  | 0.12279    | 0.12279    | 0.12279    |   0.0 |  0.16
Other   |            | 0.01044    |            |       |  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:       323128 ave      323128 max      323128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323128
Ave neighs/atom = 80.782
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.38190716029, Press = -1.19309815624
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13087.459     -13087.459     -13260.117     -13260.117      334.01832      334.01832      67587.696      67587.696     -748.50425     -748.50425    
     11000  -13088.606     -13088.606     -13259.46      -13259.46       330.52887      330.52887      67498.625      67498.625      393.51968      393.51968    
Loop time of 76.8906 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.124 ns/day, 21.359 hours/ns, 13.005 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    | 76.735     | 76.735     | 76.735     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022046   | 0.022046   | 0.022046   |   0.0 |  0.03
Output  | 4.8612e-05 | 4.8612e-05 | 4.8612e-05 |   0.0 |  0.00
Modify  | 0.1229     | 0.1229     | 0.1229     |   0.0 |  0.16
Other   |            | 0.01048    |            |       |  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:       322806 ave      322806 max      322806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322806
Ave neighs/atom = 80.7015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.542159584548, Press = 0.595335105941451
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13088.606     -13088.606     -13259.46      -13259.46       330.52887      330.52887      67498.625      67498.625      393.51968      393.51968    
     12000  -13090.591     -13090.591     -13260.642     -13260.642      328.97483      328.97483      67566.932      67566.932     -490.42179     -490.42179    
Loop time of 76.8155 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.125 ns/day, 21.338 hours/ns, 13.018 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    | 76.66      | 76.66      | 76.66      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021935   | 0.021935   | 0.021935   |   0.0 |  0.03
Output  | 4.4334e-05 | 4.4334e-05 | 4.4334e-05 |   0.0 |  0.00
Modify  | 0.12282    | 0.12282    | 0.12282    |   0.0 |  0.16
Other   |            | 0.01045    |            |       |  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:       323026 ave      323026 max      323026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323026
Ave neighs/atom = 80.7565
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.287001721953, Press = -1.18108984232221
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13090.591     -13090.591     -13260.642     -13260.642      328.97483      328.97483      67566.932      67566.932     -490.42179     -490.42179    
     13000  -13081.771     -13081.771     -13258.592     -13258.592      342.0705       342.0705       67463.06       67463.06       912.50298      912.50298    
Loop time of 76.9664 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.123 ns/day, 21.380 hours/ns, 12.993 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    | 76.811     | 76.811     | 76.811     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021956   | 0.021956   | 0.021956   |   0.0 |  0.03
Output  | 4.1979e-05 | 4.1979e-05 | 4.1979e-05 |   0.0 |  0.00
Modify  | 0.12272    | 0.12272    | 0.12272    |   0.0 |  0.16
Other   |            | 0.0104     |            |       |  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:       322840 ave      322840 max      322840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322840
Ave neighs/atom = 80.71
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.3760230921, Press = 3.33059250176243
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13081.771     -13081.771     -13258.592     -13258.592      342.0705       342.0705       67463.06       67463.06       912.50298      912.50298    
     14000  -13086.163     -13086.163     -13259.018     -13259.018      334.40001      334.40001      67609.293      67609.293     -827.96971     -827.96971    
Loop time of 77.1047 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.121 ns/day, 21.418 hours/ns, 12.969 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    | 76.949     | 76.949     | 76.949     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021987   | 0.021987   | 0.021987   |   0.0 |  0.03
Output  | 7.1525e-05 | 7.1525e-05 | 7.1525e-05 |   0.0 |  0.00
Modify  | 0.12298    | 0.12298    | 0.12298    |   0.0 |  0.16
Other   |            | 0.01045    |            |       |  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:       323154 ave      323154 max      323154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323154
Ave neighs/atom = 80.7885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.480585668951, Press = -5.38883502983052
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13086.163     -13086.163     -13259.018     -13259.018      334.40001      334.40001      67609.293      67609.293     -827.96971     -827.96971    
     15000  -13087.965     -13087.965     -13257.488     -13257.488      327.95339      327.95339      67532.641      67532.641      31.519948      31.519948    
Loop time of 77.0037 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.122 ns/day, 21.390 hours/ns, 12.986 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    | 76.848     | 76.848     | 76.848     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022091   | 0.022091   | 0.022091   |   0.0 |  0.03
Output  | 5.0455e-05 | 5.0455e-05 | 5.0455e-05 |   0.0 |  0.00
Modify  | 0.12346    | 0.12346    | 0.12346    |   0.0 |  0.16
Other   |            | 0.01053    |            |       |  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:       322678 ave      322678 max      322678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322678
Ave neighs/atom = 80.6695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.692071537069, Press = 2.71048300416155
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13087.965     -13087.965     -13257.488     -13257.488      327.95339      327.95339      67532.641      67532.641      31.519948      31.519948    
     16000  -13092.075     -13092.075     -13262.359     -13262.359      329.4262       329.4262       67459.717      67459.717      593.07758      593.07758    
Loop time of 76.9465 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.123 ns/day, 21.374 hours/ns, 12.996 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    | 76.791     | 76.791     | 76.791     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02186    | 0.02186    | 0.02186    |   0.0 |  0.03
Output  | 4.0316e-05 | 4.0316e-05 | 4.0316e-05 |   0.0 |  0.00
Modify  | 0.1227     | 0.1227     | 0.1227     |   0.0 |  0.16
Other   |            | 0.0104     |            |       |  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:       323026 ave      323026 max      323026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323026
Ave neighs/atom = 80.7565
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.604433710702, Press = -1.11003731529289
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13092.075     -13092.075     -13262.359     -13262.359      329.4262       329.4262       67459.717      67459.717      593.07758      593.07758    
     17000  -13085.18      -13085.18      -13256.581     -13256.581      331.58622      331.58622      67583.157      67583.157     -352.39644     -352.39644    
Loop time of 76.9867 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.122 ns/day, 21.385 hours/ns, 12.989 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    | 76.83      | 76.83      | 76.83      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022244   | 0.022244   | 0.022244   |   0.0 |  0.03
Output  | 4.2109e-05 | 4.2109e-05 | 4.2109e-05 |   0.0 |  0.00
Modify  | 0.12365    | 0.12365    | 0.12365    |   0.0 |  0.16
Other   |            | 0.01052    |            |       |  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:       323248 ave      323248 max      323248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323248
Ave neighs/atom = 80.812
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.567357203575, Press = -0.178135730500311
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13085.18      -13085.18      -13256.581     -13256.581      331.58622      331.58622      67583.157      67583.157     -352.39644     -352.39644    
     18000  -13089.474     -13089.474     -13260.711     -13260.711      331.26978      331.26978      67435.754      67435.754      1031.3244      1031.3244    
Loop time of 76.9547 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.123 ns/day, 21.376 hours/ns, 12.995 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    | 76.799     | 76.799     | 76.799     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021903   | 0.021903   | 0.021903   |   0.0 |  0.03
Output  | 3.9805e-05 | 3.9805e-05 | 3.9805e-05 |   0.0 |  0.00
Modify  | 0.12287    | 0.12287    | 0.12287    |   0.0 |  0.16
Other   |            | 0.01048    |            |       |  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:       322808 ave      322808 max      322808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322808
Ave neighs/atom = 80.702
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.455873474553, Press = 0.254401927194314
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13089.474     -13089.474     -13260.711     -13260.711      331.26978      331.26978      67435.754      67435.754      1031.3244      1031.3244    
     19000  -13085.24      -13085.24      -13258.338     -13258.338      334.87023      334.87023      67677.131      67677.131     -1529.2063     -1529.2063    
Loop time of 76.9125 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.123 ns/day, 21.365 hours/ns, 13.002 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    | 76.757     | 76.757     | 76.757     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021889   | 0.021889   | 0.021889   |   0.0 |  0.03
Output  | 3.8021e-05 | 3.8021e-05 | 3.8021e-05 |   0.0 |  0.00
Modify  | 0.1227     | 0.1227     | 0.1227     |   0.0 |  0.16
Other   |            | 0.01049    |            |       |  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:       323228 ave      323228 max      323228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323228
Ave neighs/atom = 80.807
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.395044219265, Press = -2.13670997030263
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13085.24      -13085.24      -13258.338     -13258.338      334.87023      334.87023      67677.131      67677.131     -1529.2063     -1529.2063    
     20000  -13089.644     -13089.644     -13259.707     -13259.707      328.99771      328.99771      67442.932      67442.932      946.30512      946.30512    
Loop time of 76.9191 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.123 ns/day, 21.366 hours/ns, 13.001 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    | 76.764     | 76.764     | 76.764     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02171    | 0.02171    | 0.02171    |   0.0 |  0.03
Output  | 4.1929e-05 | 4.1929e-05 | 4.1929e-05 |   0.0 |  0.00
Modify  | 0.12249    | 0.12249    | 0.12249    |   0.0 |  0.16
Other   |            | 0.01035    |            |       |  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:       322508 ave      322508 max      322508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322508
Ave neighs/atom = 80.627
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.319197194773, Press = 2.14506965402675
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13089.644     -13089.644     -13259.707     -13259.707      328.99771      328.99771      67442.932      67442.932      946.30512      946.30512    
     21000  -13090.256     -13090.256     -13261.289     -13261.289      330.87374      330.87374      67532.925      67532.925     -186.78824     -186.78824    
Loop time of 76.9402 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.123 ns/day, 21.372 hours/ns, 12.997 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    | 76.784     | 76.784     | 76.784     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021895   | 0.021895   | 0.021895   |   0.0 |  0.03
Output  | 4.0185e-05 | 4.0185e-05 | 4.0185e-05 |   0.0 |  0.00
Modify  | 0.12354    | 0.12354    | 0.12354    |   0.0 |  0.16
Other   |            | 0.0105     |            |       |  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:       323216 ave      323216 max      323216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323216
Ave neighs/atom = 80.804
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.35590832772, Press = -1.65684924409675
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13090.256     -13090.256     -13261.289     -13261.289      330.87374      330.87374      67532.925      67532.925     -186.78824     -186.78824    
     22000  -13081.621     -13081.621     -13253.868     -13253.868      333.22337      333.22337      67562.333      67562.333     -8.640418      -8.640418     
Loop time of 77.0306 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.122 ns/day, 21.397 hours/ns, 12.982 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    | 76.875     | 76.875     | 76.875     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021787   | 0.021787   | 0.021787   |   0.0 |  0.03
Output  | 3.7912e-05 | 3.7912e-05 | 3.7912e-05 |   0.0 |  0.00
Modify  | 0.12303    | 0.12303    | 0.12303    |   0.0 |  0.16
Other   |            | 0.01054    |            |       |  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:       323050 ave      323050 max      323050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323050
Ave neighs/atom = 80.7625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.494236117443, Press = 0.0996916278464093
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13081.621     -13081.621     -13253.868     -13253.868      333.22337      333.22337      67562.333      67562.333     -8.640418      -8.640418     
     23000  -13087.998     -13087.998     -13260.81      -13260.81       334.31678      334.31678      67505.576      67505.576      192.06043      192.06043    
Loop time of 76.9536 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.123 ns/day, 21.376 hours/ns, 12.995 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    | 76.799     | 76.799     | 76.799     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021731   | 0.021731   | 0.021731   |   0.0 |  0.03
Output  | 4.0416e-05 | 4.0416e-05 | 4.0416e-05 |   0.0 |  0.00
Modify  | 0.12266    | 0.12266    | 0.12266    |   0.0 |  0.16
Other   |            | 0.01039    |            |       |  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:       323004 ave      323004 max      323004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323004
Ave neighs/atom = 80.751
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.602082671942, Press = -0.631443117282239
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13087.998     -13087.998     -13260.81      -13260.81       334.31678      334.31678      67505.576      67505.576      192.06043      192.06043    
     24000  -13085.116     -13085.116     -13257.978     -13257.978      334.41206      334.41206      67586.54       67586.54      -459.92106     -459.92106    
Loop time of 77.0478 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.121 ns/day, 21.402 hours/ns, 12.979 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    | 76.892     | 76.892     | 76.892     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022062   | 0.022062   | 0.022062   |   0.0 |  0.03
Output  | 4.1759e-05 | 4.1759e-05 | 4.1759e-05 |   0.0 |  0.00
Modify  | 0.12348    | 0.12348    | 0.12348    |   0.0 |  0.16
Other   |            | 0.01046    |            |       |  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:       323100 ave      323100 max      323100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323100
Ave neighs/atom = 80.775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.633120055575, Press = 0.484145401944043
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13085.116     -13085.116     -13257.978     -13257.978      334.41206      334.41206      67586.54       67586.54      -459.92106     -459.92106    
     25000  -13089.601     -13089.601     -13260.266     -13260.266      330.16392      330.16392      67446.312      67446.312      891.29986      891.29986    
Loop time of 77.0185 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.122 ns/day, 21.394 hours/ns, 12.984 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    | 76.863     | 76.863     | 76.863     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022131   | 0.022131   | 0.022131   |   0.0 |  0.03
Output  | 4.256e-05  | 4.256e-05  | 4.256e-05  |   0.0 |  0.00
Modify  | 0.12323    | 0.12323    | 0.12323    |   0.0 |  0.16
Other   |            | 0.01046    |            |       |  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:       322824 ave      322824 max      322824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322824
Ave neighs/atom = 80.706
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.612411508111, Press = -1.10841088309425
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13089.601     -13089.601     -13260.266     -13260.266      330.16392      330.16392      67446.312      67446.312      891.29986      891.29986    
     26000  -13087.672     -13087.672     -13258.064     -13258.064      329.63448      329.63448      67648.541      67648.541     -1187.578      -1187.578     
Loop time of 77.0559 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.121 ns/day, 21.404 hours/ns, 12.978 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    | 76.901     | 76.901     | 76.901     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021826   | 0.021826   | 0.021826   |   0.0 |  0.03
Output  | 4.1538e-05 | 4.1538e-05 | 4.1538e-05 |   0.0 |  0.00
Modify  | 0.12253    | 0.12253    | 0.12253    |   0.0 |  0.16
Other   |            | 0.01037    |            |       |  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:       323210 ave      323210 max      323210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323210
Ave neighs/atom = 80.8025
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.629304118675, Press = 0.0867755061209655
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13087.672     -13087.672     -13258.064     -13258.064      329.63448      329.63448      67648.541      67648.541     -1187.578      -1187.578     
     27000  -13089.901     -13089.901     -13262.263     -13262.263      333.44506      333.44506      67405.561      67405.561      1227.0309      1227.0309    
Loop time of 76.8398 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.124 ns/day, 21.344 hours/ns, 13.014 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    | 76.684     | 76.684     | 76.684     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022081   | 0.022081   | 0.022081   |   0.0 |  0.03
Output  | 0.00010095 | 0.00010095 | 0.00010095 |   0.0 |  0.00
Modify  | 0.12317    | 0.12317    | 0.12317    |   0.0 |  0.16
Other   |            | 0.01046    |            |       |  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:       322608 ave      322608 max      322608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322608
Ave neighs/atom = 80.652
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.531601304268, Press = 0.37669032038566
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13089.901     -13089.901     -13262.263     -13262.263      333.44506      333.44506      67405.561      67405.561      1227.0309      1227.0309    
     28000  -13088.961     -13088.961     -13260.224     -13260.224      331.31915      331.31915      67584.002      67584.002     -695.15783     -695.15783    
Loop time of 77.2192 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.119 ns/day, 21.450 hours/ns, 12.950 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    | 77.063     | 77.063     | 77.063     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022066   | 0.022066   | 0.022066   |   0.0 |  0.03
Output  | 4.253e-05  | 4.253e-05  | 4.253e-05  |   0.0 |  0.00
Modify  | 0.12369    | 0.12369    | 0.12369    |   0.0 |  0.16
Other   |            | 0.01058    |            |       |  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:       323366 ave      323366 max      323366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323366
Ave neighs/atom = 80.8415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.516751255688, Press = -0.744554591136231
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13088.961     -13088.961     -13260.224     -13260.224      331.31915      331.31915      67584.002      67584.002     -695.15783     -695.15783    
     29000  -13089.106     -13089.106     -13260.973     -13260.973      332.48774      332.48774      67501.023      67501.023      191.86997      191.86997    
Loop time of 76.8221 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.125 ns/day, 21.339 hours/ns, 13.017 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    | 76.667     | 76.667     | 76.667     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021793   | 0.021793   | 0.021793   |   0.0 |  0.03
Output  | 3.9524e-05 | 3.9524e-05 | 3.9524e-05 |   0.0 |  0.00
Modify  | 0.12276    | 0.12276    | 0.12276    |   0.0 |  0.16
Other   |            | 0.01047    |            |       |  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:       322790 ave      322790 max      322790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322790
Ave neighs/atom = 80.6975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.45346198646, Press = 0.344193304339755
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13089.106     -13089.106     -13260.973     -13260.973      332.48774      332.48774      67501.023      67501.023      191.86997      191.86997    
     30000  -13088.374     -13088.374     -13257.788     -13257.788      327.74243      327.74243      67524.715      67524.715      139.83537      139.83537    
Loop time of 76.9473 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.123 ns/day, 21.374 hours/ns, 12.996 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    | 76.791     | 76.791     | 76.791     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02208    | 0.02208    | 0.02208    |   0.0 |  0.03
Output  | 4.5416e-05 | 4.5416e-05 | 4.5416e-05 |   0.0 |  0.00
Modify  | 0.12373    | 0.12373    | 0.12373    |   0.0 |  0.16
Other   |            | 0.01044    |            |       |  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:       322924 ave      322924 max      322924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322924
Ave neighs/atom = 80.731
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.470942107248, Press = -0.538528111675243
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13088.374     -13088.374     -13257.788     -13257.788      327.74243      327.74243      67524.715      67524.715      139.83537      139.83537    
     31000  -13084.167     -13084.167     -13256.511     -13256.511      333.41035      333.41035      67561.306      67561.306     -126.35663     -126.35663    
Loop time of 76.8952 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.124 ns/day, 21.360 hours/ns, 13.005 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    | 76.74      | 76.74      | 76.74      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021798   | 0.021798   | 0.021798   |   0.0 |  0.03
Output  | 3.8903e-05 | 3.8903e-05 | 3.8903e-05 |   0.0 |  0.00
Modify  | 0.12276    | 0.12276    | 0.12276    |   0.0 |  0.16
Other   |            | 0.01044    |            |       |  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:       323012 ave      323012 max      323012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323012
Ave neighs/atom = 80.753
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.415006701577, Press = 0.863356936480794
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13084.167     -13084.167     -13256.511     -13256.511      333.41035      333.41035      67561.306      67561.306     -126.35663     -126.35663    
     32000  -13088.589     -13088.589     -13261.579     -13261.579      334.66199      334.66199      67446.107      67446.107      826.00136      826.00136    
Loop time of 77.1007 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.121 ns/day, 21.417 hours/ns, 12.970 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    | 76.946     | 76.946     | 76.946     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021868   | 0.021868   | 0.021868   |   0.0 |  0.03
Output  | 4.0556e-05 | 4.0556e-05 | 4.0556e-05 |   0.0 |  0.00
Modify  | 0.12258    | 0.12258    | 0.12258    |   0.0 |  0.16
Other   |            | 0.01035    |            |       |  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:       322874 ave      322874 max      322874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322874
Ave neighs/atom = 80.7185
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.460226046826, Press = -1.36856913192992
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13088.589     -13088.589     -13261.579     -13261.579      334.66199      334.66199      67446.107      67446.107      826.00136      826.00136    
     33000  -13085.13      -13085.13      -13255.802     -13255.802      330.17643      330.17643      67632.264      67632.264     -857.63683     -857.63683    
Loop time of 77.1017 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.121 ns/day, 21.417 hours/ns, 12.970 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    | 76.947     | 76.947     | 76.947     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021711   | 0.021711   | 0.021711   |   0.0 |  0.03
Output  | 4.291e-05  | 4.291e-05  | 4.291e-05  |   0.0 |  0.00
Modify  | 0.12257    | 0.12257    | 0.12257    |   0.0 |  0.16
Other   |            | 0.01035    |            |       |  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:       323220 ave      323220 max      323220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323220
Ave neighs/atom = 80.805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.563403232661, Press = 0.0362302382809514
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13085.13      -13085.13      -13255.802     -13255.802      330.17643      330.17643      67632.264      67632.264     -857.63683     -857.63683    
     34000  -13086.727     -13086.727     -13260.137     -13260.137      335.47407      335.47407      67460.49       67460.49       832.8888       832.8888     
Loop time of 76.9089 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.123 ns/day, 21.364 hours/ns, 13.002 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    | 76.754     | 76.754     | 76.754     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021699   | 0.021699   | 0.021699   |   0.0 |  0.03
Output  | 4.1458e-05 | 4.1458e-05 | 4.1458e-05 |   0.0 |  0.00
Modify  | 0.12246    | 0.12246    | 0.12246    |   0.0 |  0.16
Other   |            | 0.01032    |            |       |  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:       322774 ave      322774 max      322774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322774
Ave neighs/atom = 80.6935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.620739341372, Press = 0.0844893933840628
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13086.727     -13086.727     -13260.137     -13260.137      335.47407      335.47407      67460.49       67460.49       832.8888       832.8888     
     35000  -13089.254     -13089.254     -13261.948     -13261.948      334.0871       334.0871       67584.939      67584.939     -797.84415     -797.84415    
Loop time of 77.0968 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.121 ns/day, 21.416 hours/ns, 12.971 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    | 76.942     | 76.942     | 76.942     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021852   | 0.021852   | 0.021852   |   0.0 |  0.03
Output  | 4.1508e-05 | 4.1508e-05 | 4.1508e-05 |   0.0 |  0.00
Modify  | 0.12272    | 0.12272    | 0.12272    |   0.0 |  0.16
Other   |            | 0.01033    |            |       |  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:       323282 ave      323282 max      323282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323282
Ave neighs/atom = 80.8205
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.702615417555, Press = -0.858990933967377
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13089.254     -13089.254     -13261.948     -13261.948      334.0871       334.0871       67584.939      67584.939     -797.84415     -797.84415    
     36000  -13088.407     -13088.407     -13258.523     -13258.523      329.10035      329.10035      67482.483      67482.483      610.73331      610.73331    
Loop time of 77.6217 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.113 ns/day, 21.562 hours/ns, 12.883 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    | 77.454     | 77.454     | 77.454     |   0.0 | 99.78
Neigh   | 0.011632   | 0.011632   | 0.011632   |   0.0 |  0.01
Comm    | 0.022197   | 0.022197   | 0.022197   |   0.0 |  0.03
Output  | 4.0647e-05 | 4.0647e-05 | 4.0647e-05 |   0.0 |  0.00
Modify  | 0.12301    | 0.12301    | 0.12301    |   0.0 |  0.16
Other   |            | 0.01038    |            |       |  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:       323210 ave      323210 max      323210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323210
Ave neighs/atom = 80.8025
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.722426336841, Press = 1.63024319319945
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13088.407     -13088.407     -13258.523     -13258.523      329.10035      329.10035      67482.483      67482.483      610.73331      610.73331    
     37000  -13086.969     -13086.969     -13259.545     -13259.545      333.86059      333.86059      67524.796      67524.796      34.911361      34.911361    
Loop time of 77.1025 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.121 ns/day, 21.417 hours/ns, 12.970 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    | 76.948     | 76.948     | 76.948     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02166    | 0.02166    | 0.02166    |   0.0 |  0.03
Output  | 4.5065e-05 | 4.5065e-05 | 4.5065e-05 |   0.0 |  0.00
Modify  | 0.12284    | 0.12284    | 0.12284    |   0.0 |  0.16
Other   |            | 0.01034    |            |       |  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:       323124 ave      323124 max      323124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323124
Ave neighs/atom = 80.781
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.727323362723, Press = -1.65830197300272
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13086.969     -13086.969     -13259.545     -13259.545      333.86059      333.86059      67524.796      67524.796      34.911361      34.911361    
     38000  -13090.221     -13090.221     -13261.332     -13261.332      331.02514      331.02514      67537.138      67537.138     -146.32557     -146.32557    
Loop time of 77.136 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.120 ns/day, 21.427 hours/ns, 12.964 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    | 76.981     | 76.981     | 76.981     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021741   | 0.021741   | 0.021741   |   0.0 |  0.03
Output  | 4.1569e-05 | 4.1569e-05 | 4.1569e-05 |   0.0 |  0.00
Modify  | 0.12268    | 0.12268    | 0.12268    |   0.0 |  0.16
Other   |            | 0.01036    |            |       |  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:       323052 ave      323052 max      323052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323052
Ave neighs/atom = 80.763
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.702332332461, Press = 0.608189891179857
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13090.221     -13090.221     -13261.332     -13261.332      331.02514      331.02514      67537.138      67537.138     -146.32557     -146.32557    
     39000  -13082.944     -13082.944     -13259.779     -13259.779      342.09822      342.09822      67539.228      67539.228     -10.899478     -10.899478    
Loop time of 76.7715 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.125 ns/day, 21.325 hours/ns, 13.026 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    | 76.617     | 76.617     | 76.617     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021816   | 0.021816   | 0.021816   |   0.0 |  0.03
Output  | 4.3382e-05 | 4.3382e-05 | 4.3382e-05 |   0.0 |  0.00
Modify  | 0.12245    | 0.12245    | 0.12245    |   0.0 |  0.16
Other   |            | 0.01042    |            |       |  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:       322870 ave      322870 max      322870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322870
Ave neighs/atom = 80.7175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.734503947682, Press = -0.677654248491373
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13082.944     -13082.944     -13259.779     -13259.779      342.09822      342.09822      67539.228      67539.228     -10.899478     -10.899478    
     40000  -13089.781     -13089.781     -13259.978     -13259.978      329.25601      329.25601      67541.458      67541.458     -180.82444     -180.82444    
Loop time of 77.0204 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.122 ns/day, 21.395 hours/ns, 12.984 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    | 76.866     | 76.866     | 76.866     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021681   | 0.021681   | 0.021681   |   0.0 |  0.03
Output  | 4.1098e-05 | 4.1098e-05 | 4.1098e-05 |   0.0 |  0.00
Modify  | 0.12254    | 0.12254    | 0.12254    |   0.0 |  0.16
Other   |            | 0.01038    |            |       |  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:       322932 ave      322932 max      322932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322932
Ave neighs/atom = 80.733
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.793354863314, Press = 0.261652196571917
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13089.781     -13089.781     -13259.978     -13259.978      329.25601      329.25601      67541.458      67541.458     -180.82444     -180.82444    
     41000  -13091.247     -13091.247     -13264.482     -13264.482      335.13412      335.13412      67449.12       67449.12       618.81425      618.81425    
Loop time of 76.8997 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.124 ns/day, 21.361 hours/ns, 13.004 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    | 76.745     | 76.745     | 76.745     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021784   | 0.021784   | 0.021784   |   0.0 |  0.03
Output  | 4.1338e-05 | 4.1338e-05 | 4.1338e-05 |   0.0 |  0.00
Modify  | 0.12233    | 0.12233    | 0.12233    |   0.0 |  0.16
Other   |            | 0.0103     |            |       |  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:       323048 ave      323048 max      323048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323048
Ave neighs/atom = 80.762
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.819889701489, Press = -0.359397248322982
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13091.247     -13091.247     -13264.482     -13264.482      335.13412      335.13412      67449.12       67449.12       618.81425      618.81425    
     42000  -13086.766     -13086.766     -13257.004     -13257.004      329.33744      329.33744      67658.349      67658.349     -1320.5703     -1320.5703    
Loop time of 76.9781 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.122 ns/day, 21.383 hours/ns, 12.991 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    | 76.824     | 76.824     | 76.824     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021626   | 0.021626   | 0.021626   |   0.0 |  0.03
Output  | 4.1899e-05 | 4.1899e-05 | 4.1899e-05 |   0.0 |  0.00
Modify  | 0.12219    | 0.12219    | 0.12219    |   0.0 |  0.16
Other   |            | 0.01032    |            |       |  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:       323142 ave      323142 max      323142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323142
Ave neighs/atom = 80.7855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.770109212047, Press = 0.0243376675369605
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13086.766     -13086.766     -13257.004     -13257.004      329.33744      329.33744      67658.349      67658.349     -1320.5703     -1320.5703    
     43000  -13092.723     -13092.723     -13261.806     -13261.806      327.10326      327.10326      67403.08       67403.08       1207.0617      1207.0617    
Loop time of 76.9326 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.123 ns/day, 21.370 hours/ns, 12.998 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    | 76.778     | 76.778     | 76.778     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02172    | 0.02172    | 0.02172    |   0.0 |  0.03
Output  | 4.0587e-05 | 4.0587e-05 | 4.0587e-05 |   0.0 |  0.00
Modify  | 0.12257    | 0.12257    | 0.12257    |   0.0 |  0.16
Other   |            | 0.01037    |            |       |  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:       322610 ave      322610 max      322610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322610
Ave neighs/atom = 80.6525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.769802516015, Press = 0.177499139191519
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13092.723     -13092.723     -13261.806     -13261.806      327.10326      327.10326      67403.08       67403.08       1207.0617      1207.0617    
     44000  -13084.712     -13084.712     -13257.228     -13257.228      333.74361      333.74361      67603.445      67603.445     -700.37074     -700.37074    
Loop time of 76.8709 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.124 ns/day, 21.353 hours/ns, 13.009 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    | 76.716     | 76.716     | 76.716     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021718   | 0.021718   | 0.021718   |   0.0 |  0.03
Output  | 4.1238e-05 | 4.1238e-05 | 4.1238e-05 |   0.0 |  0.00
Modify  | 0.12237    | 0.12237    | 0.12237    |   0.0 |  0.16
Other   |            | 0.01035    |            |       |  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:       323252 ave      323252 max      323252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323252
Ave neighs/atom = 80.813
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.720412053089, Press = -0.685059193793764
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13084.712     -13084.712     -13257.228     -13257.228      333.74361      333.74361      67603.445      67603.445     -700.37074     -700.37074    
     45000  -13089.601     -13089.601     -13260.362     -13260.362      330.34771      330.34771      67502.492      67502.492      249.33437      249.33437    
Loop time of 76.9771 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.122 ns/day, 21.383 hours/ns, 12.991 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    | 76.823     | 76.823     | 76.823     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021727   | 0.021727   | 0.021727   |   0.0 |  0.03
Output  | 4.0426e-05 | 4.0426e-05 | 4.0426e-05 |   0.0 |  0.00
Modify  | 0.12246    | 0.12246    | 0.12246    |   0.0 |  0.16
Other   |            | 0.01035    |            |       |  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:       322686 ave      322686 max      322686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322686
Ave neighs/atom = 80.6715
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.710201743779, Press = 0.444703518884428
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13089.601     -13089.601     -13260.362     -13260.362      330.34771      330.34771      67502.492      67502.492      249.33437      249.33437    
     46000  -13080.659     -13080.659     -13256.952     -13256.952      341.05159      341.05159      67536.749      67536.749      182.17183      182.17183    
Loop time of 76.8909 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.124 ns/day, 21.359 hours/ns, 13.005 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    | 76.736     | 76.736     | 76.736     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021784   | 0.021784   | 0.021784   |   0.0 |  0.03
Output  | 3.6879e-05 | 3.6879e-05 | 3.6879e-05 |   0.0 |  0.00
Modify  | 0.1223     | 0.1223     | 0.1223     |   0.0 |  0.16
Other   |            | 0.01036    |            |       |  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:       323062 ave      323062 max      323062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323062
Ave neighs/atom = 80.7655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.746587943353, Press = -0.366928930398113
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13080.659     -13080.659     -13256.952     -13256.952      341.05159      341.05159      67536.749      67536.749      182.17183      182.17183    
     47000  -13088.147     -13088.147     -13259.999     -13259.999      332.45868      332.45868      67585.619      67585.619     -724.43191     -724.43191    
Loop time of 76.9498 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.123 ns/day, 21.375 hours/ns, 12.995 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    | 76.795     | 76.795     | 76.795     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021756   | 0.021756   | 0.021756   |   0.0 |  0.03
Output  | 4.8591e-05 | 4.8591e-05 | 4.8591e-05 |   0.0 |  0.00
Modify  | 0.12254    | 0.12254    | 0.12254    |   0.0 |  0.16
Other   |            | 0.01034    |            |       |  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:       322928 ave      322928 max      322928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322928
Ave neighs/atom = 80.732
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.782792377814, Press = 0.140336776824105
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -13088.147     -13088.147     -13259.999     -13259.999      332.45868      332.45868      67585.619      67585.619     -724.43191     -724.43191    
     48000  -13085.69      -13085.69      -13256.731     -13256.731      330.88998      330.88998      67409.18       67409.18       1606.2983      1606.2983    
Loop time of 77.0764 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.121 ns/day, 21.410 hours/ns, 12.974 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    | 76.922     | 76.922     | 76.922     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021764   | 0.021764   | 0.021764   |   0.0 |  0.03
Output  | 4.9844e-05 | 4.9844e-05 | 4.9844e-05 |   0.0 |  0.00
Modify  | 0.12276    | 0.12276    | 0.12276    |   0.0 |  0.16
Other   |            | 0.01036    |            |       |  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:       322794 ave      322794 max      322794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322794
Ave neighs/atom = 80.6985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.776586874673, Press = -0.393474372044366
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -13085.69      -13085.69      -13256.731     -13256.731      330.88998      330.88998      67409.18       67409.18       1606.2983      1606.2983    
     49000  -13093.904     -13093.904     -13262.184     -13262.184      325.54772      325.54772      67654.828      67654.828     -1582.2971     -1582.2971    
Loop time of 77.0054 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.122 ns/day, 21.390 hours/ns, 12.986 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    | 76.851     | 76.851     | 76.851     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021634   | 0.021634   | 0.021634   |   0.0 |  0.03
Output  | 5.0635e-05 | 5.0635e-05 | 5.0635e-05 |   0.0 |  0.00
Modify  | 0.1227     | 0.1227     | 0.1227     |   0.0 |  0.16
Other   |            | 0.01037    |            |       |  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:       323314 ave      323314 max      323314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323314
Ave neighs/atom = 80.8285
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.777604385861, Press = -0.214829474199124
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -13093.904     -13093.904     -13262.184     -13262.184      325.54772      325.54772      67654.828      67654.828     -1582.2971     -1582.2971    
     50000  -13087.577     -13087.577     -13258.48      -13258.48       330.62508      330.62508      67442.759      67442.759      1024.4303      1024.4303    
Loop time of 76.8064 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.125 ns/day, 21.335 hours/ns, 13.020 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    | 76.652     | 76.652     | 76.652     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021662   | 0.021662   | 0.021662   |   0.0 |  0.03
Output  | 4.6718e-05 | 4.6718e-05 | 4.6718e-05 |   0.0 |  0.00
Modify  | 0.12273    | 0.12273    | 0.12273    |   0.0 |  0.16
Other   |            | 0.01039    |            |       |  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:       322592 ave      322592 max      322592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322592
Ave neighs/atom = 80.648
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.73204715619, Press = 0.286061490959661
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -13087.577     -13087.577     -13258.48      -13258.48       330.62508      330.62508      67442.759      67442.759      1024.4303      1024.4303    
     51000  -13091.356     -13091.356     -13260.312     -13260.312      326.85772      326.85772      67538.238      67538.238     -222.94938     -222.94938    
Loop time of 76.9164 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.123 ns/day, 21.366 hours/ns, 13.001 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    | 76.762     | 76.762     | 76.762     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021771   | 0.021771   | 0.021771   |   0.0 |  0.03
Output  | 5.0455e-05 | 5.0455e-05 | 5.0455e-05 |   0.0 |  0.00
Modify  | 0.12256    | 0.12256    | 0.12256    |   0.0 |  0.16
Other   |            | 0.01036    |            |       |  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:       323342 ave      323342 max      323342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323342
Ave neighs/atom = 80.8355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.719850248661, Press = -0.283466181183472
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -13091.356     -13091.356     -13260.312     -13260.312      326.85772      326.85772      67538.238      67538.238     -222.94938     -222.94938    
     52000  -13084.793     -13084.793     -13254.619     -13254.619      328.54068      328.54068      67554.614      67554.614      98.788659      98.788659    
Loop time of 76.7701 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.125 ns/day, 21.325 hours/ns, 13.026 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    | 76.615     | 76.615     | 76.615     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02179    | 0.02179    | 0.02179    |   0.0 |  0.03
Output  | 7.6545e-05 | 7.6545e-05 | 7.6545e-05 |   0.0 |  0.00
Modify  | 0.12272    | 0.12272    | 0.12272    |   0.0 |  0.16
Other   |            | 0.01039    |            |       |  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:       322908 ave      322908 max      322908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322908
Ave neighs/atom = 80.727
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.696083618266, Press = -0.00665594251380929
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -13084.793     -13084.793     -13254.619     -13254.619      328.54068      328.54068      67554.614      67554.614      98.788659      98.788659    
     53000  -13086.941     -13086.941     -13257.923     -13257.923      330.77649      330.77649      67540.776      67540.776     -6.7759066     -6.7759066    
Loop time of 77.0201 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.122 ns/day, 21.394 hours/ns, 12.984 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    | 76.865     | 76.865     | 76.865     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02174    | 0.02174    | 0.02174    |   0.0 |  0.03
Output  | 4.9954e-05 | 4.9954e-05 | 4.9954e-05 |   0.0 |  0.00
Modify  | 0.12267    | 0.12267    | 0.12267    |   0.0 |  0.16
Other   |            | 0.01039    |            |       |  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:       323002 ave      323002 max      323002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323002
Ave neighs/atom = 80.7505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.713944698875, Press = -0.0612679090144958
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -13086.941     -13086.941     -13257.923     -13257.923      330.77649      330.77649      67540.776      67540.776     -6.7759066     -6.7759066    
     54000  -13084.443     -13084.443     -13258.924     -13258.924      337.54458      337.54458      67514.06       67514.06       270.82962      270.82962    
Loop time of 76.9945 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.122 ns/day, 21.387 hours/ns, 12.988 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    | 76.84      | 76.84      | 76.84      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021758   | 0.021758   | 0.021758   |   0.0 |  0.03
Output  | 5.6046e-05 | 5.6046e-05 | 5.6046e-05 |   0.0 |  0.00
Modify  | 0.12266    | 0.12266    | 0.12266    |   0.0 |  0.16
Other   |            | 0.01038    |            |       |  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:       322990 ave      322990 max      322990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322990
Ave neighs/atom = 80.7475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.770154707646, Press = -0.216935815955366
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -13084.443     -13084.443     -13258.924     -13258.924      337.54458      337.54458      67514.06       67514.06       270.82962      270.82962    
     55000  -13084.449     -13084.449     -13258.598     -13258.598      336.90262      336.90262      67590.286      67590.286     -545.24873     -545.24873    
Loop time of 76.9494 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.123 ns/day, 21.375 hours/ns, 12.996 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    | 76.794     | 76.794     | 76.794     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021828   | 0.021828   | 0.021828   |   0.0 |  0.03
Output  | 5.0385e-05 | 5.0385e-05 | 5.0385e-05 |   0.0 |  0.00
Modify  | 0.12265    | 0.12265    | 0.12265    |   0.0 |  0.16
Other   |            | 0.0104     |            |       |  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:       323040 ave      323040 max      323040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323040
Ave neighs/atom = 80.76
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.78369876487, Press = -0.202691642583036
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -13084.449     -13084.449     -13258.598     -13258.598      336.90262      336.90262      67590.286      67590.286     -545.24873     -545.24873    
     56000  -13087.802     -13087.802     -13261.089     -13261.089      335.23534      335.23534      67491.269      67491.269      280.17218      280.17218    
Loop time of 76.9194 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.123 ns/day, 21.367 hours/ns, 13.001 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    | 76.765     | 76.765     | 76.765     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021672   | 0.021672   | 0.021672   |   0.0 |  0.03
Output  | 5.1327e-05 | 5.1327e-05 | 5.1327e-05 |   0.0 |  0.00
Modify  | 0.12261    | 0.12261    | 0.12261    |   0.0 |  0.16
Other   |            | 0.01036    |            |       |  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:       322678 ave      322678 max      322678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322678
Ave neighs/atom = 80.6695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.836621237833, Press = 0.155756785781437
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -13087.802     -13087.802     -13261.089     -13261.089      335.23534      335.23534      67491.269      67491.269      280.17218      280.17218    
     57000  -13081.106     -13081.106     -13255.097     -13255.097      336.59708      336.59708      67596.661      67596.661     -336.05098     -336.05098    
Loop time of 76.9822 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.122 ns/day, 21.384 hours/ns, 12.990 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    | 76.827     | 76.827     | 76.827     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021759   | 0.021759   | 0.021759   |   0.0 |  0.03
Output  | 4.5296e-05 | 4.5296e-05 | 4.5296e-05 |   0.0 |  0.00
Modify  | 0.12278    | 0.12278    | 0.12278    |   0.0 |  0.16
Other   |            | 0.01039    |            |       |  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:       323110 ave      323110 max      323110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323110
Ave neighs/atom = 80.7775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.867266821714, Press = -0.383534446450274
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -13081.106     -13081.106     -13255.097     -13255.097      336.59708      336.59708      67596.661      67596.661     -336.05098     -336.05098    
     58000  -13088.602     -13088.602     -13260.525     -13260.525      332.59675      332.59675      67525.097      67525.097     -27.620165     -27.620165    
Loop time of 76.9045 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.123 ns/day, 21.362 hours/ns, 13.003 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    | 76.751     | 76.751     | 76.751     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021374   | 0.021374   | 0.021374   |   0.0 |  0.03
Output  | 5.4543e-05 | 5.4543e-05 | 5.4543e-05 |   0.0 |  0.00
Modify  | 0.12158    | 0.12158    | 0.12158    |   0.0 |  0.16
Other   |            | 0.01034    |            |       |  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:       322930 ave      322930 max      322930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322930
Ave neighs/atom = 80.7325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.897322952261, Press = 0.403677338323472
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -13088.602     -13088.602     -13260.525     -13260.525      332.59675      332.59675      67525.097      67525.097     -27.620165     -27.620165    
     59000  -13086.468     -13086.468     -13256.638     -13256.638      329.20457      329.20457      67530.761      67530.761      249.07894      249.07894    
Loop time of 76.7662 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.125 ns/day, 21.324 hours/ns, 13.027 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    | 76.613     | 76.613     | 76.613     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021408   | 0.021408   | 0.021408   |   0.0 |  0.03
Output  | 4.9784e-05 | 4.9784e-05 | 4.9784e-05 |   0.0 |  0.00
Modify  | 0.1214     | 0.1214     | 0.1214     |   0.0 |  0.16
Other   |            | 0.01028    |            |       |  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:       322976 ave      322976 max      322976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322976
Ave neighs/atom = 80.744
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.919852463491, Press = -0.60237271326883
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -13086.468     -13086.468     -13256.638     -13256.638      329.20457      329.20457      67530.761      67530.761      249.07894      249.07894    
     60000  -13089.65      -13089.65      -13261.893     -13261.893      333.21485      333.21485      67556.69       67556.69      -451.0894      -451.0894     
Loop time of 76.8337 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.125 ns/day, 21.343 hours/ns, 13.015 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    | 76.68      | 76.68      | 76.68      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021313   | 0.021313   | 0.021313   |   0.0 |  0.03
Output  | 5.1267e-05 | 5.1267e-05 | 5.1267e-05 |   0.0 |  0.00
Modify  | 0.12139    | 0.12139    | 0.12139    |   0.0 |  0.16
Other   |            | 0.01049    |            |       |  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:       323018 ave      323018 max      323018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323018
Ave neighs/atom = 80.7545
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.929998101677, Press = 0.3297092239368
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -13089.65      -13089.65      -13261.893     -13261.893      333.21485      333.21485      67556.69       67556.69      -451.0894      -451.0894     
     61000  -13084.038     -13084.038     -13256.723     -13256.723      334.07094      334.07094      67474.586      67474.586      881.80305      881.80305    
Loop time of 76.6898 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.127 ns/day, 21.303 hours/ns, 13.040 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    | 76.537     | 76.537     | 76.537     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021359   | 0.021359   | 0.021359   |   0.0 |  0.03
Output  | 4.9243e-05 | 4.9243e-05 | 4.9243e-05 |   0.0 |  0.00
Modify  | 0.12136    | 0.12136    | 0.12136    |   0.0 |  0.16
Other   |            | 0.01033    |            |       |  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:       322900 ave      322900 max      322900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322900
Ave neighs/atom = 80.725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.912246348926, Press = -0.650064745767101
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -13084.038     -13084.038     -13256.723     -13256.723      334.07094      334.07094      67474.586      67474.586      881.80305      881.80305    
     62000  -13089.582     -13089.582     -13260.356     -13260.356      330.37394      330.37394      67645.936      67645.936     -1378.7511     -1378.7511    
Loop time of 76.7632 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.126 ns/day, 21.323 hours/ns, 13.027 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    | 76.61      | 76.61      | 76.61      |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021463   | 0.021463   | 0.021463   |   0.0 |  0.03
Output  | 5.1216e-05 | 5.1216e-05 | 5.1216e-05 |   0.0 |  0.00
Modify  | 0.12139    | 0.12139    | 0.12139    |   0.0 |  0.16
Other   |            | 0.0103     |            |       |  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:       323198 ave      323198 max      323198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323198
Ave neighs/atom = 80.7995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.912482886725, Press = 0.37402843088474
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -13089.582     -13089.582     -13260.356     -13260.356      330.37394      330.37394      67645.936      67645.936     -1378.7511     -1378.7511    
     63000  -13086.005     -13086.005     -13260.955     -13260.955      338.45212      338.45212      67494.128      67494.128      363.76237      363.76237    
Loop time of 76.9024 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.124 ns/day, 21.362 hours/ns, 13.003 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    | 76.749     | 76.749     | 76.749     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021322   | 0.021322   | 0.021322   |   0.0 |  0.03
Output  | 4.9523e-05 | 4.9523e-05 | 4.9523e-05 |   0.0 |  0.00
Modify  | 0.1216     | 0.1216     | 0.1216     |   0.0 |  0.16
Other   |            | 0.0103     |            |       |  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:       322804 ave      322804 max      322804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322804
Ave neighs/atom = 80.701
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.923160660017, Press = -0.175460691840833
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -13086.005     -13086.005     -13260.955     -13260.955      338.45212      338.45212      67494.128      67494.128      363.76237      363.76237    
     64000  -13087.902     -13087.902     -13260.266     -13260.266      333.44931      333.44931      67580.951      67580.951     -622.98087     -622.98087    
Loop time of 76.9587 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.123 ns/day, 21.377 hours/ns, 12.994 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    | 76.805     | 76.805     | 76.805     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021402   | 0.021402   | 0.021402   |   0.0 |  0.03
Output  | 4.1348e-05 | 4.1348e-05 | 4.1348e-05 |   0.0 |  0.00
Modify  | 0.12154    | 0.12154    | 0.12154    |   0.0 |  0.16
Other   |            | 0.0103     |            |       |  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:       323092 ave      323092 max      323092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323092
Ave neighs/atom = 80.773
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.933114173131, Press = -0.140477243759967
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -13087.902     -13087.902     -13260.266     -13260.266      333.44931      333.44931      67580.951      67580.951     -622.98087     -622.98087    
     65000  -13084.725     -13084.725     -13260.34      -13260.34       339.74013      339.74013      67469.33       67469.33       705.65214      705.65214    
Loop time of 76.7556 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.126 ns/day, 21.321 hours/ns, 13.028 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    | 76.602     | 76.602     | 76.602     |   0.0 | 99.80
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021443   | 0.021443   | 0.021443   |   0.0 |  0.03
Output  | 4.9734e-05 | 4.9734e-05 | 4.9734e-05 |   0.0 |  0.00
Modify  | 0.12154    | 0.12154    | 0.12154    |   0.0 |  0.16
Other   |            | 0.01063    |            |       |  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:       322844 ave      322844 max      322844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322844
Ave neighs/atom = 80.711
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
67532.1007279611

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0