# 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.044650778174401*${_u_distance}
variable latticeconst_converted equal 4.044650778174401*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.0446507781744
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_2016_AlTi__MO_618133763375_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.250676169    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66167.250676169/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66167.250676169/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 66167.250676169/(1*1*${_u_distance})
variable      V0_metal equal 66167.250676169/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 66167.250676169*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66167.250676169 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_618133763375_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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.251      66167.251      2779.917       2779.917     
      1000  -13075.359     -13075.359     -13255.181     -13255.181      347.8789       347.8789       67709.656      67709.656     -1536.5061     -1536.5061    
Loop time of 77.1665 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.120 ns/day, 21.435 hours/ns, 12.959 timesteps/s
73.2% 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.959     | 76.959     | 76.959     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024434   | 0.024434   | 0.024434   |   0.0 |  0.03
Output  | 0.00018618 | 0.00018618 | 0.00018618 |   0.0 |  0.00
Modify  | 0.15768    | 0.15768    | 0.15768    |   0.0 |  0.20
Other   |            | 0.02493    |            |       |  0.03

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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.5061     -1536.5061    
      2000  -13094.787     -13094.787     -13266.546     -13266.546      332.27821      332.27821      67471.612      67471.612      217.76982      217.76982    
Loop time of 75.2555 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.148 ns/day, 20.904 hours/ns, 13.288 timesteps/s
85.9% 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.058     | 75.058     | 75.058     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040599   | 0.040599   | 0.040599   |   0.0 |  0.05
Output  | 0.00010932 | 0.00010932 | 0.00010932 |   0.0 |  0.00
Modify  | 0.14286    | 0.14286    | 0.14286    |   0.0 |  0.19
Other   |            | 0.01359    |            |       |  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:       312416 ave      312416 max      312416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312416
Ave neighs/atom = 78.104
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.27821      332.27821      67471.612      67471.612      217.76982      217.76982    
      3000  -13081.184     -13081.184     -13252.35      -13252.35       331.13171      331.13171      67555.778      67555.778      226.53249      226.53249    
Loop time of 89.2697 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.968 ns/day, 24.797 hours/ns, 11.202 timesteps/s
74.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 89.007     | 89.007     | 89.007     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05186    | 0.05186    | 0.05186    |   0.0 |  0.06
Output  | 0.00011004 | 0.00011004 | 0.00011004 |   0.0 |  0.00
Modify  | 0.19768    | 0.19768    | 0.19768    |   0.0 |  0.22
Other   |            | 0.01327    |            |       |  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:       312566 ave      312566 max      312566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312566
Ave neighs/atom = 78.1415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.53249      226.53249    
      4000  -13091.557     -13091.557     -13261.588     -13261.588      328.9354       328.9354       67536.578      67536.578     -235.0802      -235.0802     
Loop time of 97.7234 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.884 ns/day, 27.145 hours/ns, 10.233 timesteps/s
68.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.439     | 97.439     | 97.439     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055922   | 0.055922   | 0.055922   |   0.0 |  0.06
Output  | 0.00011669 | 0.00011669 | 0.00011669 |   0.0 |  0.00
Modify  | 0.21568    | 0.21568    | 0.21568    |   0.0 |  0.22
Other   |            | 0.01319    |            |       |  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:       312502 ave      312502 max      312502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312502
Ave neighs/atom = 78.1255
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.0802      -235.0802     
      5000  -13085.454     -13085.454     -13259.453     -13259.453      336.61234      336.61234      67526.099      67526.099      52.387422      52.387422    
Loop time of 89.5295 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.965 ns/day, 24.869 hours/ns, 11.170 timesteps/s
76.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 89.316     | 89.316     | 89.316     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035226   | 0.035226   | 0.035226   |   0.0 |  0.04
Output  | 6.1205e-05 | 6.1205e-05 | 6.1205e-05 |   0.0 |  0.00
Modify  | 0.16518    | 0.16518    | 0.16518    |   0.0 |  0.18
Other   |            | 0.01303    |            |       |  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:       312430 ave      312430 max      312430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312430
Ave neighs/atom = 78.1075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.060475125132, Press = -157.454799294105
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.61234      336.61234      67526.099      67526.099      52.387422      52.387422    
      6000  -13087.075     -13087.075     -13259.941     -13259.941      334.42212      334.42212      67568.171      67568.171     -435.75791     -435.75791    
Loop time of 84.344 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.024 ns/day, 23.429 hours/ns, 11.856 timesteps/s
81.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 84.118     | 84.118     | 84.118     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024839   | 0.024839   | 0.024839   |   0.0 |  0.03
Output  | 7.6053e-05 | 7.6053e-05 | 7.6053e-05 |   0.0 |  0.00
Modify  | 0.18812    | 0.18812    | 0.18812    |   0.0 |  0.22
Other   |            | 0.01317    |            |       |  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:       312554 ave      312554 max      312554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312554
Ave neighs/atom = 78.1385
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.721317715032, Press = 15.0148706325486
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.42212      334.42212      67568.171      67568.171     -435.75791     -435.75791    
      7000  -13088.344     -13088.344     -13260.093     -13260.093      332.25963      332.25963      67444.711      67444.711      906.02871      906.02871    
Loop time of 80.5709 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.072 ns/day, 22.381 hours/ns, 12.411 timesteps/s
85.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 80.35      | 80.35      | 80.35      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025094   | 0.025094   | 0.025094   |   0.0 |  0.03
Output  | 7.45e-05   | 7.45e-05   | 7.45e-05   |   0.0 |  0.00
Modify  | 0.16448    | 0.16448    | 0.16448    |   0.0 |  0.20
Other   |            | 0.03121    |            |       |  0.04

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

Total # of neighbors = 312484
Ave neighs/atom = 78.121
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.207552289104, Press = -19.9537435990658
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.25963      332.25963      67444.711      67444.711      906.02871      906.02871    
      8000  -13087.19      -13087.19      -13255.991     -13255.991      326.55662      326.55662      67668.771      67668.771     -1396.3915     -1396.3915    
Loop time of 73.162 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.181 ns/day, 20.323 hours/ns, 13.668 timesteps/s
93.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    | 72.994     | 72.994     | 72.994     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02398    | 0.02398    | 0.02398    |   0.0 |  0.03
Output  | 7.958e-05  | 7.958e-05  | 7.958e-05  |   0.0 |  0.00
Modify  | 0.13194    | 0.13194    | 0.13194    |   0.0 |  0.18
Other   |            | 0.01197    |            |       |  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:       312666 ave      312666 max      312666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312666
Ave neighs/atom = 78.1665
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.928827153519, Press = 6.3204721461526
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.771      67668.771     -1396.3915     -1396.3915    
      9000  -13091.307     -13091.307     -13260.989     -13260.989      328.26262      328.26262      67431.108      67431.108      935.11843      935.11843    
Loop time of 71.6024 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.207 ns/day, 19.890 hours/ns, 13.966 timesteps/s
97.3% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 71.433     | 71.433     | 71.433     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024154   | 0.024154   | 0.024154   |   0.0 |  0.03
Output  | 7.6363e-05 | 7.6363e-05 | 7.6363e-05 |   0.0 |  0.00
Modify  | 0.13331    | 0.13331    | 0.13331    |   0.0 |  0.19
Other   |            | 0.01182    |            |       |  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:       312396 ave      312396 max      312396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312396
Ave neighs/atom = 78.099
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.689063304085, Press = -1.15741834949595
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.26262      328.26262      67431.108      67431.108      935.11843      935.11843    
     10000  -13087.459     -13087.459     -13260.117     -13260.117      334.01821      334.01821      67587.695      67587.695     -748.4962      -748.4962     
Loop time of 71.3289 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.211 ns/day, 19.814 hours/ns, 14.020 timesteps/s
97.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 71.158     | 71.158     | 71.158     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024145   | 0.024145   | 0.024145   |   0.0 |  0.03
Output  | 8.0932e-05 | 8.0932e-05 | 8.0932e-05 |   0.0 |  0.00
Modify  | 0.13414    | 0.13414    | 0.13414    |   0.0 |  0.19
Other   |            | 0.01207    |            |       |  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:       312714 ave      312714 max      312714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312714
Ave neighs/atom = 78.1785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.381908175271, Press = -1.19311443199931
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.01821      334.01821      67587.695      67587.695     -748.4962      -748.4962     
     11000  -13088.606     -13088.606     -13259.46      -13259.46       330.52865      330.52865      67498.624      67498.624      393.51078      393.51078    
Loop time of 70.1746 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.231 ns/day, 19.493 hours/ns, 14.250 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 70.006     | 70.006     | 70.006     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024086   | 0.024086   | 0.024086   |   0.0 |  0.03
Output  | 8.8756e-05 | 8.8756e-05 | 8.8756e-05 |   0.0 |  0.00
Modify  | 0.1327     | 0.1327     | 0.1327     |   0.0 |  0.19
Other   |            | 0.01146    |            |       |  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:       312524 ave      312524 max      312524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312524
Ave neighs/atom = 78.131
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.542148139822, Press = 0.595363733087175
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.52865      330.52865      67498.624      67498.624      393.51078      393.51078    
     12000  -13090.59      -13090.59      -13260.642     -13260.642      328.97563      328.97563      67566.929      67566.929     -490.3604      -490.3604     
Loop time of 71.0122 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.217 ns/day, 19.726 hours/ns, 14.082 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    | 70.842     | 70.842     | 70.842     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024746   | 0.024746   | 0.024746   |   0.0 |  0.03
Output  | 7.997e-05  | 7.997e-05  | 7.997e-05  |   0.0 |  0.00
Modify  | 0.13395    | 0.13395    | 0.13395    |   0.0 |  0.19
Other   |            | 0.01169    |            |       |  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:       312560 ave      312560 max      312560 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312560
Ave neighs/atom = 78.14
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.287015976342, Press = -1.18113593736228
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.59      -13090.59      -13260.642     -13260.642      328.97563      328.97563      67566.929      67566.929     -490.3604      -490.3604     
     13000  -13081.776     -13081.776     -13258.594     -13258.594      342.06681      342.06681      67463.049      67463.049      912.4481       912.4481     
Loop time of 72.4047 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.193 ns/day, 20.112 hours/ns, 13.811 timesteps/s
97.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    | 72.224     | 72.224     | 72.224     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025532   | 0.025532   | 0.025532   |   0.0 |  0.04
Output  | 6.0403e-05 | 6.0403e-05 | 6.0403e-05 |   0.0 |  0.00
Modify  | 0.14148    | 0.14148    | 0.14148    |   0.0 |  0.20
Other   |            | 0.01394    |            |       |  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:       312578 ave      312578 max      312578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312578
Ave neighs/atom = 78.1445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.375978706753, Press = 3.3305577007864
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.776     -13081.776     -13258.594     -13258.594      342.06681      342.06681      67463.049      67463.049      912.4481       912.4481     
     14000  -13086.155     -13086.155     -13259.014     -13259.014      334.40611      334.40611      67609.299      67609.299     -827.67558     -827.67558    
Loop time of 71.1074 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.215 ns/day, 19.752 hours/ns, 14.063 timesteps/s
99.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 70.926     | 70.926     | 70.926     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025746   | 0.025746   | 0.025746   |   0.0 |  0.04
Output  | 7.8307e-05 | 7.8307e-05 | 7.8307e-05 |   0.0 |  0.00
Modify  | 0.14152    | 0.14152    | 0.14152    |   0.0 |  0.20
Other   |            | 0.01449    |            |       |  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:       312664 ave      312664 max      312664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312664
Ave neighs/atom = 78.166
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.480415517915, Press = -5.38842786433096
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.155     -13086.155     -13259.014     -13259.014      334.40611      334.40611      67609.299      67609.299     -827.67558     -827.67558    
     15000  -13087.942     -13087.942     -13257.473     -13257.473      327.97047      327.97047      67532.767      67532.767      31.251651      31.251651    
Loop time of 72.2274 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.196 ns/day, 20.063 hours/ns, 13.845 timesteps/s
98.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 72.033     | 72.033     | 72.033     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02722    | 0.02722    | 0.02722    |   0.0 |  0.04
Output  | 7.972e-05  | 7.972e-05  | 7.972e-05  |   0.0 |  0.00
Modify  | 0.15001    | 0.15001    | 0.15001    |   0.0 |  0.21
Other   |            | 0.01699    |            |       |  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:       312448 ave      312448 max      312448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312448
Ave neighs/atom = 78.112
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.691479503167, Press = 2.71155356561566
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.942     -13087.942     -13257.473     -13257.473      327.97047      327.97047      67532.767      67532.767      31.251651      31.251651    
     16000  -13092.074     -13092.074     -13262.359     -13262.359      329.42837      329.42837      67459.717      67459.717      593.06163      593.06163    
Loop time of 72.0561 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.199 ns/day, 20.016 hours/ns, 13.878 timesteps/s
98.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 71.842     | 71.842     | 71.842     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.027336   | 0.027336   | 0.027336   |   0.0 |  0.04
Output  | 8.0161e-05 | 8.0161e-05 | 8.0161e-05 |   0.0 |  0.00
Modify  | 0.16916    | 0.16916    | 0.16916    |   0.0 |  0.23
Other   |            | 0.01719    |            |       |  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:       312476 ave      312476 max      312476 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312476
Ave neighs/atom = 78.119
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.602579543004, Press = -1.10381590742516
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.074     -13092.074     -13262.359     -13262.359      329.42837      329.42837      67459.717      67459.717      593.06163      593.06163    
     17000  -13085.217     -13085.217     -13256.599     -13256.599      331.55028      331.55028      67583.201      67583.201     -354.48982     -354.48982    
Loop time of 69.9962 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.234 ns/day, 19.443 hours/ns, 14.286 timesteps/s
98.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    | 69.827     | 69.827     | 69.827     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024182   | 0.024182   | 0.024182   |   0.0 |  0.03
Output  | 0.00030108 | 0.00030108 | 0.00030108 |   0.0 |  0.00
Modify  | 0.13239    | 0.13239    | 0.13239    |   0.0 |  0.19
Other   |            | 0.01187    |            |       |  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:       312638 ave      312638 max      312638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312638
Ave neighs/atom = 78.1595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.565580173137, Press = -0.165751302872226
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.217     -13085.217     -13256.599     -13256.599      331.55028      331.55028      67583.201      67583.201     -354.48982     -354.48982    
     18000  -13089.382     -13089.382     -13260.664     -13260.664      331.35613      331.35613      67434.196      67434.196      1053.0261      1053.0261    
Loop time of 66.5367 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.299 ns/day, 18.482 hours/ns, 15.029 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.37      | 66.37      | 66.37      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023636   | 0.023636   | 0.023636   |   0.0 |  0.04
Output  | 7.5361e-05 | 7.5361e-05 | 7.5361e-05 |   0.0 |  0.00
Modify  | 0.13053    | 0.13053    | 0.13053    |   0.0 |  0.20
Other   |            | 0.01258    |            |       |  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:       312556 ave      312556 max      312556 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312556
Ave neighs/atom = 78.139
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.453053410949, Press = 0.20477957362119
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.382     -13089.382     -13260.664     -13260.664      331.35613      331.35613      67434.196      67434.196      1053.0261      1053.0261    
     19000  -13085.389     -13085.389     -13258.403     -13258.403      334.70735      334.70735      67678.557      67678.557     -1551.1209     -1551.1209    
Loop time of 66.5128 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.299 ns/day, 18.476 hours/ns, 15.035 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.349     | 66.349     | 66.349     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023261   | 0.023261   | 0.023261   |   0.0 |  0.03
Output  | 6.2026e-05 | 6.2026e-05 | 6.2026e-05 |   0.0 |  0.00
Modify  | 0.12904    | 0.12904    | 0.12904    |   0.0 |  0.19
Other   |            | 0.01188    |            |       |  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:       312664 ave      312664 max      312664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312664
Ave neighs/atom = 78.166
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.39844269083, Press = -2.1115705444654
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.389     -13085.389     -13258.403     -13258.403      334.70735      334.70735      67678.557      67678.557     -1551.1209     -1551.1209    
     20000  -13088.468     -13088.468     -13259.022     -13259.022      329.94873      329.94873      67446.18       67446.18       965.69719      965.69719    
Loop time of 66.9168 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.291 ns/day, 18.588 hours/ns, 14.944 timesteps/s
99.3% 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.736     | 66.736     | 66.736     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025573   | 0.025573   | 0.025573   |   0.0 |  0.04
Output  | 7.3408e-05 | 7.3408e-05 | 7.3408e-05 |   0.0 |  0.00
Modify  | 0.13961    | 0.13961    | 0.13961    |   0.0 |  0.21
Other   |            | 0.01501    |            |       |  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:       312404 ave      312404 max      312404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312404
Ave neighs/atom = 78.101
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.32596807613, Press = 2.13670061275227
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13088.468     -13088.468     -13259.022     -13259.022      329.94873      329.94873      67446.18       67446.18       965.69719      965.69719    
     21000  -13090.589     -13090.589     -13261.478     -13261.478      330.59578      330.59578      67526.763      67526.763     -132.82649     -132.82649    
Loop time of 66.7138 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.295 ns/day, 18.532 hours/ns, 14.989 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.524     | 66.524     | 66.524     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.026789   | 0.026789   | 0.026789   |   0.0 |  0.04
Output  | 8.2585e-05 | 8.2585e-05 | 8.2585e-05 |   0.0 |  0.00
Modify  | 0.14571    | 0.14571    | 0.14571    |   0.0 |  0.22
Other   |            | 0.01717    |            |       |  0.03

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

Total # of neighbors = 312604
Ave neighs/atom = 78.151
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.368975536848, Press = -1.44475453506135
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.589     -13090.589     -13261.478     -13261.478      330.59578      330.59578      67526.763      67526.763     -132.82649     -132.82649    
     22000  -13086.258     -13086.258     -13256.402     -13256.402      329.15557      329.15557      67541.695      67541.695      11.462293      11.462293    
Loop time of 66.8081 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.293 ns/day, 18.558 hours/ns, 14.968 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.616     | 66.616     | 66.616     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.027482   | 0.027482   | 0.027482   |   0.0 |  0.04
Output  | 7.7265e-05 | 7.7265e-05 | 7.7265e-05 |   0.0 |  0.00
Modify  | 0.14732    | 0.14732    | 0.14732    |   0.0 |  0.22
Other   |            | 0.0175     |            |       |  0.03

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

Total # of neighbors = 312542
Ave neighs/atom = 78.1355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.400426787937, Press = 0.850290876219963
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13086.258     -13086.258     -13256.402     -13256.402      329.15557      329.15557      67541.695      67541.695      11.462293      11.462293    
     23000  -13093.715     -13093.715     -13263.73      -13263.73       328.90606      328.90606      67457.893      67457.893      476.90016      476.90016    
Loop time of 66.5637 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.298 ns/day, 18.490 hours/ns, 15.023 timesteps/s
99.5% 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.374     | 66.374     | 66.374     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.026716   | 0.026716   | 0.026716   |   0.0 |  0.04
Output  | 7.8848e-05 | 7.8848e-05 | 7.8848e-05 |   0.0 |  0.00
Modify  | 0.14599    | 0.14599    | 0.14599    |   0.0 |  0.22
Other   |            | 0.01712    |            |       |  0.03

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

Total # of neighbors = 312556
Ave neighs/atom = 78.139
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.411150800304, Press = -1.51772073341873
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13093.715     -13093.715     -13263.73      -13263.73       328.90606      328.90606      67457.893      67457.893      476.90016      476.90016    
     24000  -13084.504     -13084.504     -13257.404     -13257.404      334.48804      334.48804      67674.517      67674.517     -1408.8754     -1408.8754    
Loop time of 66.5143 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.299 ns/day, 18.476 hours/ns, 15.034 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.344     | 66.344     | 66.344     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024767   | 0.024767   | 0.024767   |   0.0 |  0.04
Output  | 0.00014134 | 0.00014134 | 0.00014134 |   0.0 |  0.00
Modify  | 0.1328     | 0.1328     | 0.1328     |   0.0 |  0.20
Other   |            | 0.0128     |            |       |  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:       312638 ave      312638 max      312638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312638
Ave neighs/atom = 78.1595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.382532572829, Press = 2.29524816893574
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13084.504     -13084.504     -13257.404     -13257.404      334.48804      334.48804      67674.517      67674.517     -1408.8754     -1408.8754    
     25000  -13089.888     -13089.888     -13260.675     -13260.675      330.39905      330.39905      67393.458      67393.458      1465.7857      1465.7857    
Loop time of 66.6826 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.296 ns/day, 18.523 hours/ns, 14.996 timesteps/s
99.4% 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.517     | 66.517     | 66.517     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024203   | 0.024203   | 0.024203   |   0.0 |  0.04
Output  | 8.01e-05   | 8.01e-05   | 8.01e-05   |   0.0 |  0.00
Modify  | 0.12974    | 0.12974    | 0.12974    |   0.0 |  0.19
Other   |            | 0.01173    |            |       |  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:       312406 ave      312406 max      312406 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312406
Ave neighs/atom = 78.1015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.422707728114, Press = -1.13156581572782
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.888     -13089.888     -13260.675     -13260.675      330.39905      330.39905      67393.458      67393.458      1465.7857      1465.7857    
     26000  -13084.227     -13084.227     -13256.455     -13256.455      333.18718      333.18718      67622.94       67622.94      -755.71081     -755.71081    
Loop time of 66.6851 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.296 ns/day, 18.524 hours/ns, 14.996 timesteps/s
99.3% 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.521     | 66.521     | 66.521     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023783   | 0.023783   | 0.023783   |   0.0 |  0.04
Output  | 0.00031271 | 0.00031271 | 0.00031271 |   0.0 |  0.00
Modify  | 0.12846    | 0.12846    | 0.12846    |   0.0 |  0.19
Other   |            | 0.01169    |            |       |  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:       312728 ave      312728 max      312728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312728
Ave neighs/atom = 78.182
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.52070233228, Press = -0.53461296897627
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13084.227     -13084.227     -13256.455     -13256.455      333.18718      333.18718      67622.94       67622.94      -755.71081     -755.71081    
     27000  -13087.926     -13087.926     -13261.395     -13261.395      335.5892       335.5892       67449.84       67449.84       811.01354      811.01354    
Loop time of 66.5994 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.297 ns/day, 18.500 hours/ns, 15.015 timesteps/s
99.2% 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.419     | 66.419     | 66.419     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024364   | 0.024364   | 0.024364   |   0.0 |  0.04
Output  | 7.6353e-05 | 7.6353e-05 | 7.6353e-05 |   0.0 |  0.00
Modify  | 0.14278    | 0.14278    | 0.14278    |   0.0 |  0.21
Other   |            | 0.01349    |            |       |  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:       312504 ave      312504 max      312504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312504
Ave neighs/atom = 78.126
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.613710147398, Press = 0.576584214381417
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13087.926     -13087.926     -13261.395     -13261.395      335.5892       335.5892       67449.84       67449.84       811.01354      811.01354    
     28000  -13084.11      -13084.11      -13257.597     -13257.597      335.62242      335.62242      67598.292      67598.292     -642.47078     -642.47078    
Loop time of 66.7197 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.295 ns/day, 18.533 hours/ns, 14.988 timesteps/s
99.5% 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.549     | 66.549     | 66.549     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024326   | 0.024326   | 0.024326   |   0.0 |  0.04
Output  | 8.3236e-05 | 8.3236e-05 | 8.3236e-05 |   0.0 |  0.00
Modify  | 0.13366    | 0.13366    | 0.13366    |   0.0 |  0.20
Other   |            | 0.013      |            |       |  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:       312688 ave      312688 max      312688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312688
Ave neighs/atom = 78.172
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.663647710963, Press = -1.18906308027352
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13084.11      -13084.11      -13257.597     -13257.597      335.62242      335.62242      67598.292      67598.292     -642.47078     -642.47078    
     29000  -13089.76      -13089.76      -13261.258     -13261.258      331.77556      331.77556      67501.619      67501.619      155.61026      155.61026    
Loop time of 66.6429 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.296 ns/day, 18.512 hours/ns, 15.005 timesteps/s
99.1% 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.472     | 66.472     | 66.472     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02416    | 0.02416    | 0.02416    |   0.0 |  0.04
Output  | 9.2864e-05 | 9.2864e-05 | 9.2864e-05 |   0.0 |  0.00
Modify  | 0.13313    | 0.13313    | 0.13313    |   0.0 |  0.20
Other   |            | 0.01316    |            |       |  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:       312464 ave      312464 max      312464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312464
Ave neighs/atom = 78.116
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.699719287308, Press = 1.57972582006809
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.76      -13089.76      -13261.258     -13261.258      331.77556      331.77556      67501.619      67501.619      155.61026      155.61026    
     30000  -13090.146     -13090.146     -13258.728     -13258.728      326.13307      326.13307      67479.687      67479.687      551.82253      551.82253    
Loop time of 66.4915 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.299 ns/day, 18.470 hours/ns, 15.040 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.33      | 66.33      | 66.33      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02334    | 0.02334    | 0.02334    |   0.0 |  0.04
Output  | 7.1464e-05 | 7.1464e-05 | 7.1464e-05 |   0.0 |  0.00
Modify  | 0.12625    | 0.12625    | 0.12625    |   0.0 |  0.19
Other   |            | 0.01148    |            |       |  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:       312550 ave      312550 max      312550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312550
Ave neighs/atom = 78.1375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.706174928868, Press = -1.51857174013912
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13090.146     -13090.146     -13258.728     -13258.728      326.13307      326.13307      67479.687      67479.687      551.82253      551.82253    
     31000  -13086.98      -13086.98      -13257.48      -13257.48       329.84419      329.84419      67597.523      67597.523     -636.76312     -636.76312    
Loop time of 66.4419 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.300 ns/day, 18.456 hours/ns, 15.051 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.282     | 66.282     | 66.282     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022644   | 0.022644   | 0.022644   |   0.0 |  0.03
Output  | 7.0311e-05 | 7.0311e-05 | 7.0311e-05 |   0.0 |  0.00
Modify  | 0.12655    | 0.12655    | 0.12655    |   0.0 |  0.19
Other   |            | 0.01107    |            |       |  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:       312528 ave      312528 max      312528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312528
Ave neighs/atom = 78.132
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.639543596183, Press = 1.54716823379364
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13086.98      -13086.98      -13257.48      -13257.48       329.84419      329.84419      67597.523      67597.523     -636.76312     -636.76312    
     32000  -13090.78      -13090.78      -13262.052     -13262.052      331.33688      331.33688      67415.725      67415.725      1104.25        1104.25      
Loop time of 66.443 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.300 ns/day, 18.456 hours/ns, 15.051 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.283     | 66.283     | 66.283     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022703   | 0.022703   | 0.022703   |   0.0 |  0.03
Output  | 6.3018e-05 | 6.3018e-05 | 6.3018e-05 |   0.0 |  0.00
Modify  | 0.12627    | 0.12627    | 0.12627    |   0.0 |  0.19
Other   |            | 0.01098    |            |       |  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:       312538 ave      312538 max      312538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312538
Ave neighs/atom = 78.1345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.614189437095, Press = -0.841115621953239
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13090.78      -13090.78      -13262.052     -13262.052      331.33688      331.33688      67415.725      67415.725      1104.25        1104.25      
     33000  -13086.27      -13086.27      -13256.887     -13256.887      330.07059      330.07059      67614.308      67614.308     -733.17339     -733.17339    
Loop time of 66.5724 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.298 ns/day, 18.492 hours/ns, 15.021 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.399     | 66.399     | 66.399     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024573   | 0.024573   | 0.024573   |   0.0 |  0.04
Output  | 7.5511e-05 | 7.5511e-05 | 7.5511e-05 |   0.0 |  0.00
Modify  | 0.13476    | 0.13476    | 0.13476    |   0.0 |  0.20
Other   |            | 0.01362    |            |       |  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:       312606 ave      312606 max      312606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312606
Ave neighs/atom = 78.1515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.570831209204, Press = -0.0920318545888098
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13086.27      -13086.27      -13256.887     -13256.887      330.07059      330.07059      67614.308      67614.308     -733.17339     -733.17339    
     34000  -13091.783     -13091.783     -13261.926     -13261.926      329.15282      329.15282      67479.618      67479.618      427.99119      427.99119    
Loop time of 65.7506 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.314 ns/day, 18.264 hours/ns, 15.209 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    | 65.594     | 65.594     | 65.594     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02241    | 0.02241    | 0.02241    |   0.0 |  0.03
Output  | 7.5772e-05 | 7.5772e-05 | 7.5772e-05 |   0.0 |  0.00
Modify  | 0.12353    | 0.12353    | 0.12353    |   0.0 |  0.19
Other   |            | 0.01112    |            |       |  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:       312434 ave      312434 max      312434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312434
Ave neighs/atom = 78.1085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.554075868423, Press = 0.259763292579131
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13091.783     -13091.783     -13261.926     -13261.926      329.15282      329.15282      67479.618      67479.618      427.99119      427.99119    
     35000  -13085.426     -13085.426     -13257.751     -13257.751      333.37364      333.37364      67542.237      67542.237      44.547145      44.547145    
Loop time of 65.8371 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.312 ns/day, 18.288 hours/ns, 15.189 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.682     | 65.682     | 65.682     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022192   | 0.022192   | 0.022192   |   0.0 |  0.03
Output  | 4.6367e-05 | 4.6367e-05 | 4.6367e-05 |   0.0 |  0.00
Modify  | 0.12168    | 0.12168    | 0.12168    |   0.0 |  0.18
Other   |            | 0.011      |            |       |  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:       312528 ave      312528 max      312528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312528
Ave neighs/atom = 78.132
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.589071174595, Press = -0.152448028871851
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13085.426     -13085.426     -13257.751     -13257.751      333.37364      333.37364      67542.237      67542.237      44.547145      44.547145    
     36000  -13085.283     -13085.283     -13257.049     -13257.049      332.2927       332.2927       67492.953      67492.953      571.29281      571.29281    
Loop time of 65.7977 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.313 ns/day, 18.277 hours/ns, 15.198 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.638     | 65.638     | 65.638     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023302   | 0.023302   | 0.023302   |   0.0 |  0.04
Output  | 0.00015094 | 0.00015094 | 0.00015094 |   0.0 |  0.00
Modify  | 0.12269    | 0.12269    | 0.12269    |   0.0 |  0.19
Other   |            | 0.01325    |            |       |  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:       312516 ave      312516 max      312516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312516
Ave neighs/atom = 78.129
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.588956840397, Press = 0.484148296084432
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13085.283     -13085.283     -13257.049     -13257.049      332.2927       332.2927       67492.953      67492.953      571.29281      571.29281    
     37000  -13087.128     -13087.128     -13258.08      -13258.08       330.71726      330.71726      67595.583      67595.583     -599.71915     -599.71915    
Loop time of 66.2321 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.305 ns/day, 18.398 hours/ns, 15.098 timesteps/s
99.4% 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.073     | 66.073     | 66.073     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023168   | 0.023168   | 0.023168   |   0.0 |  0.03
Output  | 0.00022959 | 0.00022959 | 0.00022959 |   0.0 |  0.00
Modify  | 0.12326    | 0.12326    | 0.12326    |   0.0 |  0.19
Other   |            | 0.01243    |            |       |  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:       312600 ave      312600 max      312600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312600
Ave neighs/atom = 78.15
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.593278849987, Press = -1.81745994527952
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13087.128     -13087.128     -13258.08      -13258.08       330.71726      330.71726      67595.583      67595.583     -599.71915     -599.71915    
     38000  -13086.701     -13086.701     -13256.602     -13256.602      328.68506      328.68506      67539.989      67539.989      94.086791      94.086791    
Loop time of 66.2939 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.303 ns/day, 18.415 hours/ns, 15.084 timesteps/s
99.3% 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.134     | 66.134     | 66.134     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023434   | 0.023434   | 0.023434   |   0.0 |  0.04
Output  | 8.4869e-05 | 8.4869e-05 | 8.4869e-05 |   0.0 |  0.00
Modify  | 0.12345    | 0.12345    | 0.12345    |   0.0 |  0.19
Other   |            | 0.01306    |            |       |  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:       312480 ave      312480 max      312480 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312480
Ave neighs/atom = 78.12
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.616577534412, Press = 1.53750885664628
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13086.701     -13086.701     -13256.602     -13256.602      328.68506      328.68506      67539.989      67539.989      94.086791      94.086791    
     39000  -13087.98      -13087.98      -13260.529     -13260.529      333.80675      333.80675      67523.227      67523.227      45.024573      45.024573    
Loop time of 66.2243 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.305 ns/day, 18.396 hours/ns, 15.100 timesteps/s
99.7% 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.06      | 66.06      | 66.06      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024639   | 0.024639   | 0.024639   |   0.0 |  0.04
Output  | 7.0974e-05 | 7.0974e-05 | 7.0974e-05 |   0.0 |  0.00
Modify  | 0.12367    | 0.12367    | 0.12367    |   0.0 |  0.19
Other   |            | 0.01621    |            |       |  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:       312550 ave      312550 max      312550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312550
Ave neighs/atom = 78.1375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.628279088066, Press = -0.617391670727948
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13087.98      -13087.98      -13260.529     -13260.529      333.80675      333.80675      67523.227      67523.227      45.024573      45.024573    
     40000  -13087.309     -13087.309     -13259.186     -13259.186      332.50795      332.50795      67554.563      67554.563     -245.9963      -245.9963     
Loop time of 66.0203 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.309 ns/day, 18.339 hours/ns, 15.147 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.861     | 65.861     | 65.861     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023188   | 0.023188   | 0.023188   |   0.0 |  0.04
Output  | 9.597e-05  | 9.597e-05  | 9.597e-05  |   0.0 |  0.00
Modify  | 0.12279    | 0.12279    | 0.12279    |   0.0 |  0.19
Other   |            | 0.01346    |            |       |  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:       312510 ave      312510 max      312510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312510
Ave neighs/atom = 78.1275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.620459471539, Press = 0.375443022287541
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13087.309     -13087.309     -13259.186     -13259.186      332.50795      332.50795      67554.563      67554.563     -245.9963      -245.9963     
     41000  -13086.047     -13086.047     -13260.665     -13260.665      337.81073      337.81073      67506.227      67506.227      248.94526      248.94526    
Loop time of 66.0935 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.307 ns/day, 18.359 hours/ns, 15.130 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.934     | 65.934     | 65.934     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022942   | 0.022942   | 0.022942   |   0.0 |  0.03
Output  | 3.696e-05  | 3.696e-05  | 3.696e-05  |   0.0 |  0.00
Modify  | 0.12247    | 0.12247    | 0.12247    |   0.0 |  0.19
Other   |            | 0.01367    |            |       |  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:       312472 ave      312472 max      312472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312472
Ave neighs/atom = 78.118
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.647382294829, Press = -0.300721863715699
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13086.047     -13086.047     -13260.665     -13260.665      337.81073      337.81073      67506.227      67506.227      248.94526      248.94526    
     42000  -13092.321     -13092.321     -13263.8       -13263.8        331.73819      331.73819      67605.795      67605.795     -1177.5612     -1177.5612    
Loop time of 66.1072 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.307 ns/day, 18.363 hours/ns, 15.127 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    | 65.951     | 65.951     | 65.951     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022226   | 0.022226   | 0.022226   |   0.0 |  0.03
Output  | 5.8139e-05 | 5.8139e-05 | 5.8139e-05 |   0.0 |  0.00
Modify  | 0.12245    | 0.12245    | 0.12245    |   0.0 |  0.19
Other   |            | 0.01146    |            |       |  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:       312526 ave      312526 max      312526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312526
Ave neighs/atom = 78.1315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.650900146565, Press = 0.527858550526668
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13092.321     -13092.321     -13263.8       -13263.8        331.73819      331.73819      67605.795      67605.795     -1177.5612     -1177.5612    
     43000  -13086.495     -13086.495     -13258.339     -13258.339      332.44573      332.44573      67385.34       67385.34       1721.6359      1721.6359    
Loop time of 65.8437 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.312 ns/day, 18.290 hours/ns, 15.187 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.679     | 65.679     | 65.679     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024907   | 0.024907   | 0.024907   |   0.0 |  0.04
Output  | 8.8516e-05 | 8.8516e-05 | 8.8516e-05 |   0.0 |  0.00
Modify  | 0.12462    | 0.12462    | 0.12462    |   0.0 |  0.19
Other   |            | 0.0149     |            |       |  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:       312420 ave      312420 max      312420 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312420
Ave neighs/atom = 78.105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.606890734891, Press = -0.352441692415712
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13086.495     -13086.495     -13258.339     -13258.339      332.44573      332.44573      67385.34       67385.34       1721.6359      1721.6359    
     44000  -13092.575     -13092.575     -13262.198     -13262.198      328.14557      328.14557      67595.585      67595.585     -952.71817     -952.71817    
Loop time of 65.9291 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.310 ns/day, 18.314 hours/ns, 15.168 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.772     | 65.772     | 65.772     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022689   | 0.022689   | 0.022689   |   0.0 |  0.03
Output  | 6.4622e-05 | 6.4622e-05 | 6.4622e-05 |   0.0 |  0.00
Modify  | 0.12243    | 0.12243    | 0.12243    |   0.0 |  0.19
Other   |            | 0.01238    |            |       |  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:       312646 ave      312646 max      312646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312646
Ave neighs/atom = 78.1615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.604115180428, Press = -0.242207100770482
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13092.575     -13092.575     -13262.198     -13262.198      328.14557      328.14557      67595.585      67595.585     -952.71817     -952.71817    
     45000  -13087.103     -13087.103     -13257.077     -13257.077      328.82668      328.82668      67511.715      67511.715      370.13769      370.13769    
Loop time of 66.2777 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.304 ns/day, 18.410 hours/ns, 15.088 timesteps/s
99.3% 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.118     | 66.118     | 66.118     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023252   | 0.023252   | 0.023252   |   0.0 |  0.04
Output  | 0.00013216 | 0.00013216 | 0.00013216 |   0.0 |  0.00
Modify  | 0.12426    | 0.12426    | 0.12426    |   0.0 |  0.19
Other   |            | 0.01209    |            |       |  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:       312494 ave      312494 max      312494 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312494
Ave neighs/atom = 78.1235
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.570853808613, Press = 0.557248481702942
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13087.103     -13087.103     -13257.077     -13257.077      328.82668      328.82668      67511.715      67511.715      370.13769      370.13769    
     46000  -13086.246     -13086.246     -13256.732     -13256.732      329.81696      329.81696      67552.991      67552.991     -44.797895     -44.797895    
Loop time of 66.0651 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.308 ns/day, 18.351 hours/ns, 15.137 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.911     | 65.911     | 65.911     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021851   | 0.021851   | 0.021851   |   0.0 |  0.03
Output  | 0.00010203 | 0.00010203 | 0.00010203 |   0.0 |  0.00
Modify  | 0.12218    | 0.12218    | 0.12218    |   0.0 |  0.18
Other   |            | 0.01044    |            |       |  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:       312524 ave      312524 max      312524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312524
Ave neighs/atom = 78.131
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.594777403378, Press = -0.164868036261385
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13086.246     -13086.246     -13256.732     -13256.732      329.81696      329.81696      67552.991      67552.991     -44.797895     -44.797895    
     47000  -13090.045     -13090.045     -13260.763     -13260.763      330.26394      330.26394      67473.971      67473.971      524.25363      524.25363    
Loop time of 66.1644 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.306 ns/day, 18.379 hours/ns, 15.114 timesteps/s
99.7% 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.01      | 66.01      | 66.01      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021834   | 0.021834   | 0.021834   |   0.0 |  0.03
Output  | 6.9671e-05 | 6.9671e-05 | 6.9671e-05 |   0.0 |  0.00
Modify  | 0.12215    | 0.12215    | 0.12215    |   0.0 |  0.18
Other   |            | 0.01046    |            |       |  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:       312524 ave      312524 max      312524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312524
Ave neighs/atom = 78.131
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.61713407633, Press = 0.292993764540231
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13090.045     -13090.045     -13260.763     -13260.763      330.26394      330.26394      67473.971      67473.971      524.25363      524.25363    
     48000  -13087.304     -13087.304     -13258.248     -13258.248      330.70219      330.70219      67589.172      67589.172     -554.83745     -554.83745    
Loop time of 65.7866 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.313 ns/day, 18.274 hours/ns, 15.201 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.633     | 65.633     | 65.633     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021685   | 0.021685   | 0.021685   |   0.0 |  0.03
Output  | 6.1846e-05 | 6.1846e-05 | 6.1846e-05 |   0.0 |  0.00
Modify  | 0.12188    | 0.12188    | 0.12188    |   0.0 |  0.19
Other   |            | 0.01046    |            |       |  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:       312616 ave      312616 max      312616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312616
Ave neighs/atom = 78.154
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.638916462398, Press = -0.701296985125088
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13087.304     -13087.304     -13258.248     -13258.248      330.70219      330.70219      67589.172      67589.172     -554.83745     -554.83745    
     49000  -13087.805     -13087.805     -13259.255     -13259.255      331.6815       331.6815       67505.775      67505.775      333.10675      333.10675    
Loop time of 65.6707 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.316 ns/day, 18.242 hours/ns, 15.227 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.517     | 65.517     | 65.517     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021697   | 0.021697   | 0.021697   |   0.0 |  0.03
Output  | 6.4972e-05 | 6.4972e-05 | 6.4972e-05 |   0.0 |  0.00
Modify  | 0.12144    | 0.12144    | 0.12144    |   0.0 |  0.18
Other   |            | 0.01041    |            |       |  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:       312462 ave      312462 max      312462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312462
Ave neighs/atom = 78.1155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.650411260951, Press = 0.777286126417359
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13087.805     -13087.805     -13259.255     -13259.255      331.6815       331.6815       67505.775      67505.775      333.10675      333.10675    
     50000  -13091.136     -13091.136     -13262.021     -13262.021      330.58941      330.58941      67528.573      67528.573     -177.32455     -177.32455    
Loop time of 65.6285 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.317 ns/day, 18.230 hours/ns, 15.237 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    | 65.475     | 65.475     | 65.475     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021601   | 0.021601   | 0.021601   |   0.0 |  0.03
Output  | 4.4644e-05 | 4.4644e-05 | 4.4644e-05 |   0.0 |  0.00
Modify  | 0.12127    | 0.12127    | 0.12127    |   0.0 |  0.18
Other   |            | 0.01035    |            |       |  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:       312568 ave      312568 max      312568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312568
Ave neighs/atom = 78.142
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.601789990648, Press = -0.663617594329456
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13091.136     -13091.136     -13262.021     -13262.021      330.58941      330.58941      67528.573      67528.573     -177.32455     -177.32455    
     51000  -13085.787     -13085.787     -13258.441     -13258.441      334.0123       334.0123       67554.841      67554.841     -210.701       -210.701      
Loop time of 65.6867 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.315 ns/day, 18.246 hours/ns, 15.224 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    | 65.532     | 65.532     | 65.532     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022287   | 0.022287   | 0.022287   |   0.0 |  0.03
Output  | 7.8056e-05 | 7.8056e-05 | 7.8056e-05 |   0.0 |  0.00
Modify  | 0.12231    | 0.12231    | 0.12231    |   0.0 |  0.19
Other   |            | 0.01046    |            |       |  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:       312590 ave      312590 max      312590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312590
Ave neighs/atom = 78.1475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.625288715218, Press = 1.07824201059068
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13085.787     -13085.787     -13258.441     -13258.441      334.0123       334.0123       67554.841      67554.841     -210.701       -210.701      
     52000  -13086.337     -13086.337     -13260.699     -13260.699      337.31488      337.31488      67466.072      67466.072      736.25507      736.25507    
Loop time of 65.6533 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.316 ns/day, 18.237 hours/ns, 15.232 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.497     | 65.497     | 65.497     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022466   | 0.022466   | 0.022466   |   0.0 |  0.03
Output  | 0.00010526 | 0.00010526 | 0.00010526 |   0.0 |  0.00
Modify  | 0.12309    | 0.12309    | 0.12309    |   0.0 |  0.19
Other   |            | 0.01055    |            |       |  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:       312530 ave      312530 max      312530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312530
Ave neighs/atom = 78.1325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.629420128876, Press = -0.936288420239725
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13086.337     -13086.337     -13260.699     -13260.699      337.31488      337.31488      67466.072      67466.072      736.25507      736.25507    
     53000  -13090.018     -13090.018     -13260.082     -13260.082      328.99967      328.99967      67559.772      67559.772     -368.99114     -368.99114    
Loop time of 65.884 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.311 ns/day, 18.301 hours/ns, 15.178 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.727     | 65.727     | 65.727     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022853   | 0.022853   | 0.022853   |   0.0 |  0.03
Output  | 5.8329e-05 | 5.8329e-05 | 5.8329e-05 |   0.0 |  0.00
Modify  | 0.12352    | 0.12352    | 0.12352    |   0.0 |  0.19
Other   |            | 0.01062    |            |       |  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:       312636 ave      312636 max      312636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312636
Ave neighs/atom = 78.159
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.639249483818, Press = 0.351076505573511
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13090.018     -13090.018     -13260.082     -13260.082      328.99967      328.99967      67559.772      67559.772     -368.99114     -368.99114    
     54000  -13087.957     -13087.957     -13261.398     -13261.398      335.53272      335.53272      67498.968      67498.968      293.24252      293.24252    
Loop time of 66.0305 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.308 ns/day, 18.342 hours/ns, 15.145 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.874     | 65.874     | 65.874     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022398   | 0.022398   | 0.022398   |   0.0 |  0.03
Output  | 0.0001568  | 0.0001568  | 0.0001568  |   0.0 |  0.00
Modify  | 0.12307    | 0.12307    | 0.12307    |   0.0 |  0.19
Other   |            | 0.01058    |            |       |  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:       312514 ave      312514 max      312514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312514
Ave neighs/atom = 78.1285
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.605846173823, Press = -0.0989094992375139
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13087.957     -13087.957     -13261.398     -13261.398      335.53272      335.53272      67498.968      67498.968      293.24252      293.24252    
     55000  -13084.402     -13084.402     -13259.427     -13259.427      338.59805      338.59805      67598.973      67598.973     -632.62919     -632.62919    
Loop time of 65.5291 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.318 ns/day, 18.203 hours/ns, 15.260 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.374     | 65.374     | 65.374     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02233    | 0.02233    | 0.02233    |   0.0 |  0.03
Output  | 4.3262e-05 | 4.3262e-05 | 4.3262e-05 |   0.0 |  0.00
Modify  | 0.12237    | 0.12237    | 0.12237    |   0.0 |  0.19
Other   |            | 0.01053    |            |       |  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:       312450 ave      312450 max      312450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312450
Ave neighs/atom = 78.1125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.642944923272, Press = -0.202318746672584
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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.402     -13084.402     -13259.427     -13259.427      338.59805      338.59805      67598.973      67598.973     -632.62919     -632.62919    
     56000  -13088.746     -13088.746     -13259.945     -13259.945      331.19753      331.19753      67467.6        67467.6        686.09895      686.09895    
Loop time of 65.5399 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.318 ns/day, 18.206 hours/ns, 15.258 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.386     | 65.386     | 65.386     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021942   | 0.021942   | 0.021942   |   0.0 |  0.03
Output  | 0.00013948 | 0.00013948 | 0.00013948 |   0.0 |  0.00
Modify  | 0.12178    | 0.12178    | 0.12178    |   0.0 |  0.19
Other   |            | 0.01032    |            |       |  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:       312460 ave      312460 max      312460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312460
Ave neighs/atom = 78.115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.657189702767, Press = 0.386450580848854
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13088.746     -13088.746     -13259.945     -13259.945      331.19753      331.19753      67467.6        67467.6        686.09895      686.09895    
     57000  -13085.096     -13085.096     -13258.965     -13258.965      336.36064      336.36064      67628.577      67628.577     -990.5298      -990.5298     
Loop time of 65.6732 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.316 ns/day, 18.243 hours/ns, 15.227 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.519     | 65.519     | 65.519     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021995   | 0.021995   | 0.021995   |   0.0 |  0.03
Output  | 5.8109e-05 | 5.8109e-05 | 5.8109e-05 |   0.0 |  0.00
Modify  | 0.12186    | 0.12186    | 0.12186    |   0.0 |  0.19
Other   |            | 0.01038    |            |       |  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:       312582 ave      312582 max      312582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312582
Ave neighs/atom = 78.1455
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.649680609053, Press = -0.707499414876771
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13085.096     -13085.096     -13258.965     -13258.965      336.36064      336.36064      67628.577      67628.577     -990.5298      -990.5298     
     58000  -13085.161     -13085.161     -13256.151     -13256.151      330.79135      330.79135      67487.946      67487.946      694.90657      694.90657    
Loop time of 65.5533 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.318 ns/day, 18.209 hours/ns, 15.255 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.4       | 65.4       | 65.4       |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021718   | 0.021718   | 0.021718   |   0.0 |  0.03
Output  | 3.5286e-05 | 3.5286e-05 | 3.5286e-05 |   0.0 |  0.00
Modify  | 0.121      | 0.121      | 0.121      |   0.0 |  0.18
Other   |            | 0.01033    |            |       |  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:       312450 ave      312450 max      312450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312450
Ave neighs/atom = 78.1125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.629710572041, Press = 0.935799592460614
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13085.161     -13085.161     -13256.151     -13256.151      330.79135      330.79135      67487.946      67487.946      694.90657      694.90657    
     59000  -13082.947     -13082.947     -13257.018     -13257.018      336.75075      336.75075      67548.531      67548.531      55.124377      55.124377    
Loop time of 65.387 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.321 ns/day, 18.163 hours/ns, 15.294 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    | 65.234     | 65.234     | 65.234     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021752   | 0.021752   | 0.021752   |   0.0 |  0.03
Output  | 3.5737e-05 | 3.5737e-05 | 3.5737e-05 |   0.0 |  0.00
Modify  | 0.1211     | 0.1211     | 0.1211     |   0.0 |  0.19
Other   |            | 0.01034    |            |       |  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:       312550 ave      312550 max      312550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312550
Ave neighs/atom = 78.1375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.617161614241, Press = -0.419760774893978
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13082.947     -13082.947     -13257.018     -13257.018      336.75075      336.75075      67548.531      67548.531      55.124377      55.124377    
     60000  -13087.435     -13087.435     -13260.862     -13260.862      335.50643      335.50643      67562.239      67562.239     -408.11631     -408.11631    
Loop time of 65.8792 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.311 ns/day, 18.300 hours/ns, 15.179 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.726     | 65.726     | 65.726     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02179    | 0.02179    | 0.02179    |   0.0 |  0.03
Output  | 5.7227e-05 | 5.7227e-05 | 5.7227e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.18
Other   |            | 0.01021    |            |       |  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:       312456 ave      312456 max      312456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312456
Ave neighs/atom = 78.114
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.670279595809, Press = 0.270159233308049
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13087.435     -13087.435     -13260.862     -13260.862      335.50643      335.50643      67562.239      67562.239     -408.11631     -408.11631    
     61000  -13083.31      -13083.31      -13258.955     -13258.955      339.7968       339.7968       67523.035      67523.035      243.1986       243.1986     
Loop time of 65.6774 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.316 ns/day, 18.244 hours/ns, 15.226 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.52      | 65.52      | 65.52      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022671   | 0.022671   | 0.022671   |   0.0 |  0.03
Output  | 0.00020156 | 0.00020156 | 0.00020156 |   0.0 |  0.00
Modify  | 0.12307    | 0.12307    | 0.12307    |   0.0 |  0.19
Other   |            | 0.01102    |            |       |  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:       312522 ave      312522 max      312522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312522
Ave neighs/atom = 78.1305
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.686476972579, Press = -0.211790816202426
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13083.31      -13083.31      -13258.955     -13258.955      339.7968       339.7968       67523.035      67523.035      243.1986       243.1986     
     62000  -13090.736     -13090.736     -13263.856     -13263.856      334.9124       334.9124       67555.713      67555.713     -549.53802     -549.53802    
Loop time of 65.7578 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.314 ns/day, 18.266 hours/ns, 15.207 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.605     | 65.605     | 65.605     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021756   | 0.021756   | 0.021756   |   0.0 |  0.03
Output  | 3.712e-05  | 3.712e-05  | 3.712e-05  |   0.0 |  0.00
Modify  | 0.12118    | 0.12118    | 0.12118    |   0.0 |  0.18
Other   |            | 0.01034    |            |       |  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:       312580 ave      312580 max      312580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312580
Ave neighs/atom = 78.145
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.7292131972, Press = 0.278243994001154
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13090.736     -13090.736     -13263.856     -13263.856      334.9124       334.9124       67555.713      67555.713     -549.53802     -549.53802    
     63000  -13083.96      -13083.96      -13260.895     -13260.895      342.29296      342.29296      67461.102      67461.102      790.279        790.279      
Loop time of 65.5223 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.319 ns/day, 18.201 hours/ns, 15.262 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.369     | 65.369     | 65.369     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021578   | 0.021578   | 0.021578   |   0.0 |  0.03
Output  | 5.5354e-05 | 5.5354e-05 | 5.5354e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.19
Other   |            | 0.01029    |            |       |  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:       312572 ave      312572 max      312572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312572
Ave neighs/atom = 78.143
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.731164679237, Press = -0.684692488716476
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13083.96      -13083.96      -13260.895     -13260.895      342.29296      342.29296      67461.102      67461.102      790.279        790.279      
     64000  -13090.824     -13090.824     -13261.131     -13261.131      329.47181      329.47181      67632.899      67632.899     -1281.3663     -1281.3663    
Loop time of 65.4172 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.321 ns/day, 18.171 hours/ns, 15.286 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.264     | 65.264     | 65.264     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021536   | 0.021536   | 0.021536   |   0.0 |  0.03
Output  | 3.9224e-05 | 3.9224e-05 | 3.9224e-05 |   0.0 |  0.00
Modify  | 0.12138    | 0.12138    | 0.12138    |   0.0 |  0.19
Other   |            | 0.01039    |            |       |  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:       312608 ave      312608 max      312608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312608
Ave neighs/atom = 78.152
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.727303138442, Press = 0.231661643517744
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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  -13090.824     -13090.824     -13261.131     -13261.131      329.47181      329.47181      67632.899      67632.899     -1281.3663     -1281.3663    
     65000  -13084.07      -13084.07      -13257.463     -13257.463      335.43914      335.43914      67469.112      67469.112      850.03237      850.03237    
Loop time of 65.6217 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.317 ns/day, 18.228 hours/ns, 15.239 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.468     | 65.468     | 65.468     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021799   | 0.021799   | 0.021799   |   0.0 |  0.03
Output  | 7.1955e-05 | 7.1955e-05 | 7.1955e-05 |   0.0 |  0.00
Modify  | 0.12137    | 0.12137    | 0.12137    |   0.0 |  0.18
Other   |            | 0.01034    |            |       |  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:       312516 ave      312516 max      312516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312516
Ave neighs/atom = 78.129
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.744739911964, Press = -0.0865493472683201
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     65000  -13084.07      -13084.07      -13257.463     -13257.463      335.43914      335.43914      67469.112      67469.112      850.03237      850.03237    
     66000  -13088.554     -13088.554     -13262.671     -13262.671      336.84138      336.84138      67567.868      67567.868     -622.09351     -622.09351    
Loop time of 65.7358 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.314 ns/day, 18.260 hours/ns, 15.212 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.582     | 65.582     | 65.582     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02183    | 0.02183    | 0.02183    |   0.0 |  0.03
Output  | 4.9734e-05 | 4.9734e-05 | 4.9734e-05 |   0.0 |  0.00
Modify  | 0.12163    | 0.12163    | 0.12163    |   0.0 |  0.19
Other   |            | 0.01024    |            |       |  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:       312644 ave      312644 max      312644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312644
Ave neighs/atom = 78.161
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.764001757028, Press = -0.121367430168189
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     66000  -13088.554     -13088.554     -13262.671     -13262.671      336.84138      336.84138      67567.868      67567.868     -622.09351     -622.09351    
     67000  -13085.363     -13085.363     -13258.135     -13258.135      334.2379       334.2379       67503.728      67503.728      389.3079       389.3079     
Loop time of 65.7481 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.314 ns/day, 18.263 hours/ns, 15.210 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.595     | 65.595     | 65.595     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021697   | 0.021697   | 0.021697   |   0.0 |  0.03
Output  | 3.9264e-05 | 3.9264e-05 | 3.9264e-05 |   0.0 |  0.00
Modify  | 0.12143    | 0.12143    | 0.12143    |   0.0 |  0.18
Other   |            | 0.01031    |            |       |  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:       312558 ave      312558 max      312558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312558
Ave neighs/atom = 78.1395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.798081556004, Press = 0.152552463663562
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     67000  -13085.363     -13085.363     -13258.135     -13258.135      334.2379       334.2379       67503.728      67503.728      389.3079       389.3079     
     68000  -13088.411     -13088.411     -13259.657     -13259.657      331.28748      331.28748      67544.673      67544.673     -173.60575     -173.60575    
Loop time of 65.5926 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.317 ns/day, 18.220 hours/ns, 15.246 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.438     | 65.438     | 65.438     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021883   | 0.021883   | 0.021883   |   0.0 |  0.03
Output  | 4.4584e-05 | 4.4584e-05 | 4.4584e-05 |   0.0 |  0.00
Modify  | 0.12198    | 0.12198    | 0.12198    |   0.0 |  0.19
Other   |            | 0.01035    |            |       |  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:       312518 ave      312518 max      312518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312518
Ave neighs/atom = 78.1295
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.806723161061, Press = -0.444212598206043
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     68000  -13088.411     -13088.411     -13259.657     -13259.657      331.28748      331.28748      67544.673      67544.673     -173.60575     -173.60575    
     69000  -13087.789     -13087.789     -13258.598     -13258.598      330.44052      330.44052      67553.463      67553.463     -217.96616     -217.96616    
Loop time of 65.8143 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.313 ns/day, 18.282 hours/ns, 15.194 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.66      | 65.66      | 65.66      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021707   | 0.021707   | 0.021707   |   0.0 |  0.03
Output  | 3.9324e-05 | 3.9324e-05 | 3.9324e-05 |   0.0 |  0.00
Modify  | 0.12169    | 0.12169    | 0.12169    |   0.0 |  0.18
Other   |            | 0.01038    |            |       |  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:       312596 ave      312596 max      312596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312596
Ave neighs/atom = 78.149
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.823773130911, Press = 0.864026932156657
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     69000  -13087.789     -13087.789     -13258.598     -13258.598      330.44052      330.44052      67553.463      67553.463     -217.96616     -217.96616    
     70000  -13085.328     -13085.328     -13260.797     -13260.797      339.45788      339.45788      67486.815      67486.815      497.9891       497.9891     
Loop time of 65.7296 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.314 ns/day, 18.258 hours/ns, 15.214 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.576     | 65.576     | 65.576     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021662   | 0.021662   | 0.021662   |   0.0 |  0.03
Output  | 5.5373e-05 | 5.5373e-05 | 5.5373e-05 |   0.0 |  0.00
Modify  | 0.12178    | 0.12178    | 0.12178    |   0.0 |  0.19
Other   |            | 0.01034    |            |       |  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:       312480 ave      312480 max      312480 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312480
Ave neighs/atom = 78.12
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.794411260256, Press = -0.44976076396131
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     70000  -13085.328     -13085.328     -13260.797     -13260.797      339.45788      339.45788      67486.815      67486.815      497.9891       497.9891     
     71000  -13088.601     -13088.601     -13261.02      -13261.02       333.55715      333.55715      67562.895      67562.895     -490.797       -490.797      
Loop time of 65.5442 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.318 ns/day, 18.207 hours/ns, 15.257 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.391     | 65.391     | 65.391     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021566   | 0.021566   | 0.021566   |   0.0 |  0.03
Output  | 3.732e-05  | 3.732e-05  | 3.732e-05  |   0.0 |  0.00
Modify  | 0.1212     | 0.1212     | 0.1212     |   0.0 |  0.18
Other   |            | 0.01031    |            |       |  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:       312538 ave      312538 max      312538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312538
Ave neighs/atom = 78.1345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.800083201832, Press = 0.291901318922827
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     71000  -13088.601     -13088.601     -13261.02      -13261.02       333.55715      333.55715      67562.895      67562.895     -490.797       -490.797      
     72000  -13083.401     -13083.401     -13259.908     -13259.908      341.46481      341.46481      67527.433      67527.433      82.16457       82.16457     
Loop time of 65.5748 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.318 ns/day, 18.215 hours/ns, 15.250 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.421     | 65.421     | 65.421     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022145   | 0.022145   | 0.022145   |   0.0 |  0.03
Output  | 3.6749e-05 | 3.6749e-05 | 3.6749e-05 |   0.0 |  0.00
Modify  | 0.12132    | 0.12132    | 0.12132    |   0.0 |  0.19
Other   |            | 0.01031    |            |       |  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:       312380 ave      312380 max      312380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312380
Ave neighs/atom = 78.095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.815663128665, Press = -0.117742322823165
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     72000  -13083.401     -13083.401     -13259.908     -13259.908      341.46481      341.46481      67527.433      67527.433      82.16457       82.16457     
     73000  -13084.053     -13084.053     -13256.001     -13256.001      332.64612      332.64612      67543.346      67543.346      128.16159      128.16159    
Loop time of 65.7957 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.313 ns/day, 18.277 hours/ns, 15.199 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.642     | 65.642     | 65.642     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021632   | 0.021632   | 0.021632   |   0.0 |  0.03
Output  | 5.5966e-05 | 5.5966e-05 | 5.5966e-05 |   0.0 |  0.00
Modify  | 0.12138    | 0.12138    | 0.12138    |   0.0 |  0.18
Other   |            | 0.01035    |            |       |  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:       312538 ave      312538 max      312538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312538
Ave neighs/atom = 78.1345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.855921590044, Press = 0.147860403076181
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     73000  -13084.053     -13084.053     -13256.001     -13256.001      332.64612      332.64612      67543.346      67543.346      128.16159      128.16159    
     74000  -13089.35      -13089.35      -13260.682     -13260.682      331.45272      331.45272      67498.227      67498.227      258.33649      258.33649    
Loop time of 65.666 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.316 ns/day, 18.241 hours/ns, 15.229 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.513     | 65.513     | 65.513     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02156    | 0.02156    | 0.02156    |   0.0 |  0.03
Output  | 3.7671e-05 | 3.7671e-05 | 3.7671e-05 |   0.0 |  0.00
Modify  | 0.12102    | 0.12102    | 0.12102    |   0.0 |  0.18
Other   |            | 0.01032    |            |       |  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:       312594 ave      312594 max      312594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312594
Ave neighs/atom = 78.1485
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.868427217066, Press = -0.393828689911464
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     74000  -13089.35      -13089.35      -13260.682     -13260.682      331.45272      331.45272      67498.227      67498.227      258.33649      258.33649    
     75000  -13083.04      -13083.04      -13252.824     -13252.824      328.45793      328.45793      67582.56       67582.56      -178.30292     -178.30292    
Loop time of 65.5301 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.318 ns/day, 18.203 hours/ns, 15.260 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.377     | 65.377     | 65.377     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021599   | 0.021599   | 0.021599   |   0.0 |  0.03
Output  | 3.6588e-05 | 3.6588e-05 | 3.6588e-05 |   0.0 |  0.00
Modify  | 0.12117    | 0.12117    | 0.12117    |   0.0 |  0.18
Other   |            | 0.01027    |            |       |  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:       312498 ave      312498 max      312498 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312498
Ave neighs/atom = 78.1245
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.904501653848, Press = 0.292352080755134
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     75000  -13083.04      -13083.04      -13252.824     -13252.824      328.45793      328.45793      67582.56       67582.56      -178.30292     -178.30292    
     76000  -13088.642     -13088.642     -13260.408     -13260.408      332.29306      332.29306      67453.158      67453.158      813.84633      813.84633    
Loop time of 65.7693 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.314 ns/day, 18.269 hours/ns, 15.205 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.615     | 65.615     | 65.615     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021757   | 0.021757   | 0.021757   |   0.0 |  0.03
Output  | 0.00013615 | 0.00013615 | 0.00013615 |   0.0 |  0.00
Modify  | 0.12163    | 0.12163    | 0.12163    |   0.0 |  0.18
Other   |            | 0.01035    |            |       |  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:       312504 ave      312504 max      312504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312504
Ave neighs/atom = 78.126
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.929557588114, Press = -0.230952373269409
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     76000  -13088.642     -13088.642     -13260.408     -13260.408      332.29306      332.29306      67453.158      67453.158      813.84633      813.84633    
     77000  -13092.795     -13092.795     -13260.869     -13260.869      325.15         325.15         67660.822      67660.822     -1604.0639     -1604.0639    
Loop time of 65.5538 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.318 ns/day, 18.209 hours/ns, 15.255 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.4       | 65.4       | 65.4       |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021711   | 0.021711   | 0.021711   |   0.0 |  0.03
Output  | 5.9642e-05 | 5.9642e-05 | 5.9642e-05 |   0.0 |  0.00
Modify  | 0.12146    | 0.12146    | 0.12146    |   0.0 |  0.19
Other   |            | 0.0103     |            |       |  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:       312606 ave      312606 max      312606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312606
Ave neighs/atom = 78.1515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.888705697042, Press = 0.159253214472663
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     77000  -13092.795     -13092.795     -13260.869     -13260.869      325.15         325.15         67660.822      67660.822     -1604.0639     -1604.0639    
     78000  -13086.029     -13086.029     -13258.948     -13258.948      334.5246       334.5246       67432.863      67432.863      1206.314       1206.314     
Loop time of 65.4648 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.320 ns/day, 18.185 hours/ns, 15.275 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.311     | 65.311     | 65.311     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021706   | 0.021706   | 0.021706   |   0.0 |  0.03
Output  | 4.0927e-05 | 4.0927e-05 | 4.0927e-05 |   0.0 |  0.00
Modify  | 0.12151    | 0.12151    | 0.12151    |   0.0 |  0.19
Other   |            | 0.0103     |            |       |  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:       312438 ave      312438 max      312438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312438
Ave neighs/atom = 78.1095
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.884979096117, Press = 0.185754631961579
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     78000  -13086.029     -13086.029     -13258.948     -13258.948      334.5246       334.5246       67432.863      67432.863      1206.314       1206.314     
     79000  -13088.855     -13088.855     -13260.089     -13260.089      331.26439      331.26439      67577.074      67577.074     -582.05342     -582.05342    
Loop time of 65.573 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.318 ns/day, 18.215 hours/ns, 15.250 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.42      | 65.42      | 65.42      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021638   | 0.021638   | 0.021638   |   0.0 |  0.03
Output  | 4.1057e-05 | 4.1057e-05 | 4.1057e-05 |   0.0 |  0.00
Modify  | 0.12137    | 0.12137    | 0.12137    |   0.0 |  0.19
Other   |            | 0.01026    |            |       |  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:       312602 ave      312602 max      312602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312602
Ave neighs/atom = 78.1505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.890441071744, Press = -0.187395808468453
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     79000  -13088.855     -13088.855     -13260.089     -13260.089      331.26439      331.26439      67577.074      67577.074     -582.05342     -582.05342    
     80000  -13085.46      -13085.46      -13260.199     -13260.199      338.04404      338.04404      67494.617      67494.617      454.20874      454.20874    
Loop time of 65.5818 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.317 ns/day, 18.217 hours/ns, 15.248 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.428     | 65.428     | 65.428     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021709   | 0.021709   | 0.021709   |   0.0 |  0.03
Output  | 5.4121e-05 | 5.4121e-05 | 5.4121e-05 |   0.0 |  0.00
Modify  | 0.12149    | 0.12149    | 0.12149    |   0.0 |  0.19
Other   |            | 0.01024    |            |       |  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:       312540 ave      312540 max      312540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312540
Ave neighs/atom = 78.135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.90935335327, Press = 0.386093354117817
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     80000  -13085.46      -13085.46      -13260.199     -13260.199      338.04404      338.04404      67494.617      67494.617      454.20874      454.20874    
     81000  -13086.868     -13086.868     -13259.601     -13259.601      334.16379      334.16379      67556.912      67556.912     -254.6617      -254.6617     
Loop time of 65.7005 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.315 ns/day, 18.250 hours/ns, 15.221 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.547     | 65.547     | 65.547     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021664   | 0.021664   | 0.021664   |   0.0 |  0.03
Output  | 0.00016247 | 0.00016247 | 0.00016247 |   0.0 |  0.00
Modify  | 0.1212     | 0.1212     | 0.1212     |   0.0 |  0.18
Other   |            | 0.01032    |            |       |  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:       312562 ave      312562 max      312562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312562
Ave neighs/atom = 78.1405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.942086391145, Press = -0.436623414607761
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     81000  -13086.868     -13086.868     -13259.601     -13259.601      334.16379      334.16379      67556.912      67556.912     -254.6617      -254.6617     
     82000  -13087.121     -13087.121     -13259.908     -13259.908      334.26716      334.26716      67496.514      67496.514      316.42154      316.42154    
Loop time of 65.5127 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.319 ns/day, 18.198 hours/ns, 15.264 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.359     | 65.359     | 65.359     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021702   | 0.021702   | 0.021702   |   0.0 |  0.03
Output  | 3.5947e-05 | 3.5947e-05 | 3.5947e-05 |   0.0 |  0.00
Modify  | 0.12128    | 0.12128    | 0.12128    |   0.0 |  0.19
Other   |            | 0.01044    |            |       |  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:       312520 ave      312520 max      312520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312520
Ave neighs/atom = 78.13
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.958128008863, Press = 0.897307195665744
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     82000  -13087.121     -13087.121     -13259.908     -13259.908      334.26716      334.26716      67496.514      67496.514      316.42154      316.42154    
     83000  -13092.168     -13092.168     -13263.884     -13263.884      332.19583      332.19583      67475.843      67475.843      369.93988      369.93988    
Loop time of 65.4195 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.321 ns/day, 18.172 hours/ns, 15.286 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.266     | 65.266     | 65.266     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021819   | 0.021819   | 0.021819   |   0.0 |  0.03
Output  | 5.37e-05   | 5.37e-05   | 5.37e-05   |   0.0 |  0.00
Modify  | 0.12163    | 0.12163    | 0.12163    |   0.0 |  0.19
Other   |            | 0.01037    |            |       |  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:       312628 ave      312628 max      312628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312628
Ave neighs/atom = 78.157
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.959596735692, Press = -0.567712965763235
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     83000  -13092.168     -13092.168     -13263.884     -13263.884      332.19583      332.19583      67475.843      67475.843      369.93988      369.93988    
     84000  -13085.558     -13085.558     -13258.325     -13258.325      334.22937      334.22937      67565.444      67565.444     -331.31155     -331.31155    
Loop time of 65.4233 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.321 ns/day, 18.173 hours/ns, 15.285 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.27      | 65.27      | 65.27      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021664   | 0.021664   | 0.021664   |   0.0 |  0.03
Output  | 4.1338e-05 | 4.1338e-05 | 4.1338e-05 |   0.0 |  0.00
Modify  | 0.12131    | 0.12131    | 0.12131    |   0.0 |  0.19
Other   |            | 0.01036    |            |       |  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:       312598 ave      312598 max      312598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312598
Ave neighs/atom = 78.1495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.941464205603, Press = 0.319903281303224
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     84000  -13085.558     -13085.558     -13258.325     -13258.325      334.22937      334.22937      67565.444      67565.444     -331.31155     -331.31155    
     85000  -13088.645     -13088.645     -13257.933     -13257.933      327.4995       327.4995       67461.266      67461.266      823.53031      823.53031    
Loop time of 65.3014 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.323 ns/day, 18.139 hours/ns, 15.314 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.148     | 65.148     | 65.148     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021636   | 0.021636   | 0.021636   |   0.0 |  0.03
Output  | 4.3422e-05 | 4.3422e-05 | 4.3422e-05 |   0.0 |  0.00
Modify  | 0.1212     | 0.1212     | 0.1212     |   0.0 |  0.19
Other   |            | 0.0104     |            |       |  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:       312474 ave      312474 max      312474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312474
Ave neighs/atom = 78.1185
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.93450147813, Press = -0.112974062951416
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     85000  -13088.645     -13088.645     -13257.933     -13257.933      327.4995       327.4995       67461.266      67461.266      823.53031      823.53031    
     86000  -13085.957     -13085.957     -13260.55      -13260.55       337.76147      337.76147      67659.248      67659.248     -1418.4443     -1418.4443    
Loop time of 65.6924 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.315 ns/day, 18.248 hours/ns, 15.222 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 65.539     | 65.539     | 65.539     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021756   | 0.021756   | 0.021756   |   0.0 |  0.03
Output  | 5.5444e-05 | 5.5444e-05 | 5.5444e-05 |   0.0 |  0.00
Modify  | 0.12155    | 0.12155    | 0.12155    |   0.0 |  0.19
Other   |            | 0.01037    |            |       |  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:       312590 ave      312590 max      312590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312590
Ave neighs/atom = 78.1475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.94024859164, Press = 0.068017059552733
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     86000  -13085.957     -13085.957     -13260.55      -13260.55       337.76147      337.76147      67659.248      67659.248     -1418.4443     -1418.4443    
     87000  -13088.683     -13088.683     -13260.218     -13260.218      331.84592      331.84592      67420.34       67420.34       1132.2315      1132.2315    
Loop time of 65.5721 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.318 ns/day, 18.214 hours/ns, 15.250 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    | 65.419     | 65.419     | 65.419     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021722   | 0.021722   | 0.021722   |   0.0 |  0.03
Output  | 3.8863e-05 | 3.8863e-05 | 3.8863e-05 |   0.0 |  0.00
Modify  | 0.12142    | 0.12142    | 0.12142    |   0.0 |  0.19
Other   |            | 0.01034    |            |       |  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:       312400 ave      312400 max      312400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312400
Ave neighs/atom = 78.1
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.944663420183, Press = 0.266790917616937
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   
     87000  -13088.683     -13088.683     -13260.218     -13260.218      331.84592      331.84592      67420.34       67420.34       1132.2315      1132.2315    
     88000  -13080.808     -13080.808     -13255.988     -13255.988      338.89811      338.89811      67612.249      67612.249     -616.23291     -616.23291    
Loop time of 65.7337 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.314 ns/day, 18.259 hours/ns, 15.213 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    | 65.58      | 65.58      | 65.58      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021742   | 0.021742   | 0.021742   |   0.0 |  0.03
Output  | 0.00016989 | 0.00016989 | 0.00016989 |   0.0 |  0.00
Modify  | 0.12148    | 0.12148    | 0.12148    |   0.0 |  0.18
Other   |            | 0.01035    |            |       |  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:       312646 ave      312646 max      312646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0