# 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.004 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_CostaAgrenClavaguera_2007_AlNi__MO_131642768288_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_131642768288_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 343.727 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.251 ns/day, 95.480 hours/ns, 2.909 timesteps/s
99.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    | 342.79     | 342.79     | 342.79     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1492     | 0.1492     | 0.1492     |   0.0 |  0.04
Output  | 0.00029375 | 0.00029375 | 0.00029375 |   0.0 |  0.00
Modify  | 0.68714    | 0.68714    | 0.68714    |   0.0 |  0.20
Other   |            | 0.09832    |            |       |  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 371.103 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 103.084 hours/ns, 2.695 timesteps/s
99.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    | 370.13     | 370.13     | 370.13     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15234    | 0.15234    | 0.15234    |   0.0 |  0.04
Output  | 0.00023391 | 0.00023391 | 0.00023391 |   0.0 |  0.00
Modify  | 0.72094    | 0.72094    | 0.72094    |   0.0 |  0.19
Other   |            | 0.1008     |            |       |  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:       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 374.947 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.152 hours/ns, 2.667 timesteps/s
99.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    | 373.97     | 373.97     | 373.97     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15364    | 0.15364    | 0.15364    |   0.0 |  0.04
Output  | 0.00029291 | 0.00029291 | 0.00029291 |   0.0 |  0.00
Modify  | 0.72428    | 0.72428    | 0.72428    |   0.0 |  0.19
Other   |            | 0.101      |            |       |  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:       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 379.343 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.373 hours/ns, 2.636 timesteps/s
99.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    | 378.34     | 378.34     | 378.34     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15464    | 0.15464    | 0.15464    |   0.0 |  0.04
Output  | 0.00027136 | 0.00027136 | 0.00027136 |   0.0 |  0.00
Modify  | 0.74347    | 0.74347    | 0.74347    |   0.0 |  0.20
Other   |            | 0.1026     |            |       |  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:       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 377.563 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.879 hours/ns, 2.649 timesteps/s
99.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    | 376.57     | 376.57     | 376.57     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15476    | 0.15476    | 0.15476    |   0.0 |  0.04
Output  | 0.00018625 | 0.00018625 | 0.00018625 |   0.0 |  0.00
Modify  | 0.7372     | 0.7372     | 0.7372     |   0.0 |  0.20
Other   |            | 0.1019     |            |       |  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:       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 377.672 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.909 hours/ns, 2.648 timesteps/s
99.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    | 376.66     | 376.66     | 376.66     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15461    | 0.15461    | 0.15461    |   0.0 |  0.04
Output  | 0.0001899  | 0.0001899  | 0.0001899  |   0.0 |  0.00
Modify  | 0.75859    | 0.75859    | 0.75859    |   0.0 |  0.20
Other   |            | 0.101      |            |       |  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:       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 376.948 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.708 hours/ns, 2.653 timesteps/s
99.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    | 375.93     | 375.93     | 375.93     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15534    | 0.15534    | 0.15534    |   0.0 |  0.04
Output  | 0.00018893 | 0.00018893 | 0.00018893 |   0.0 |  0.00
Modify  | 0.76515    | 0.76515    | 0.76515    |   0.0 |  0.20
Other   |            | 0.1012     |            |       |  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:       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 375.377 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.271 hours/ns, 2.664 timesteps/s
99.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    | 374.36     | 374.36     | 374.36     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15318    | 0.15318    | 0.15318    |   0.0 |  0.04
Output  | 0.00024463 | 0.00024463 | 0.00024463 |   0.0 |  0.00
Modify  | 0.75863    | 0.75863    | 0.75863    |   0.0 |  0.20
Other   |            | 0.1007     |            |       |  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:       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 374.866 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.130 hours/ns, 2.668 timesteps/s
99.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    | 373.86     | 373.86     | 373.86     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15262    | 0.15262    | 0.15262    |   0.0 |  0.04
Output  | 0.00019371 | 0.00019371 | 0.00019371 |   0.0 |  0.00
Modify  | 0.74842    | 0.74842    | 0.74842    |   0.0 |  0.20
Other   |            | 0.1008     |            |       |  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:       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 377.365 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.823 hours/ns, 2.650 timesteps/s
99.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    | 376.34     | 376.34     | 376.34     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.154      | 0.154      | 0.154      |   0.0 |  0.04
Output  | 0.00026798 | 0.00026798 | 0.00026798 |   0.0 |  0.00
Modify  | 0.76622    | 0.76622    | 0.76622    |   0.0 |  0.20
Other   |            | 0.1019     |            |       |  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:       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 375.455 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.293 hours/ns, 2.663 timesteps/s
99.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    | 374.44     | 374.44     | 374.44     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15258    | 0.15258    | 0.15258    |   0.0 |  0.04
Output  | 0.00018936 | 0.00018936 | 0.00018936 |   0.0 |  0.00
Modify  | 0.75811    | 0.75811    | 0.75811    |   0.0 |  0.20
Other   |            | 0.1012     |            |       |  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:       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 375.126 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.202 hours/ns, 2.666 timesteps/s
99.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    | 374.12     | 374.12     | 374.12     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15413    | 0.15413    | 0.15413    |   0.0 |  0.04
Output  | 0.00018922 | 0.00018922 | 0.00018922 |   0.0 |  0.00
Modify  | 0.7557     | 0.7557     | 0.7557     |   0.0 |  0.20
Other   |            | 0.1007     |            |       |  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:       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 373.721 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.811 hours/ns, 2.676 timesteps/s
99.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    | 372.71     | 372.71     | 372.71     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15245    | 0.15245    | 0.15245    |   0.0 |  0.04
Output  | 0.00019291 | 0.00019291 | 0.00019291 |   0.0 |  0.00
Modify  | 0.75197    | 0.75197    | 0.75197    |   0.0 |  0.20
Other   |            | 0.1012     |            |       |  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:       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 375.312 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.253 hours/ns, 2.664 timesteps/s
99.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    | 374.3      | 374.3      | 374.3      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15297    | 0.15297    | 0.15297    |   0.0 |  0.04
Output  | 0.00023532 | 0.00023532 | 0.00023532 |   0.0 |  0.00
Modify  | 0.75439    | 0.75439    | 0.75439    |   0.0 |  0.20
Other   |            | 0.1007     |            |       |  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:       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 380.001 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.556 hours/ns, 2.632 timesteps/s
99.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    | 378.98     | 378.98     | 378.98     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15453    | 0.15453    | 0.15453    |   0.0 |  0.04
Output  | 0.000284   | 0.000284   | 0.000284   |   0.0 |  0.00
Modify  | 0.76772    | 0.76772    | 0.76772    |   0.0 |  0.20
Other   |            | 0.102      |            |       |  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:       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 376.985 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.718 hours/ns, 2.653 timesteps/s
99.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    | 375.97     | 375.97     | 375.97     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15328    | 0.15328    | 0.15328    |   0.0 |  0.04
Output  | 0.00029192 | 0.00029192 | 0.00029192 |   0.0 |  0.00
Modify  | 0.75822    | 0.75822    | 0.75822    |   0.0 |  0.20
Other   |            | 0.1009     |            |       |  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:       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 375.865 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.407 hours/ns, 2.661 timesteps/s
99.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    | 374.86     | 374.86     | 374.86     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15372    | 0.15372    | 0.15372    |   0.0 |  0.04
Output  | 0.00019041 | 0.00019041 | 0.00019041 |   0.0 |  0.00
Modify  | 0.75473    | 0.75473    | 0.75473    |   0.0 |  0.20
Other   |            | 0.1014     |            |       |  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:       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 375.219 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.228 hours/ns, 2.665 timesteps/s
99.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    | 374.21     | 374.21     | 374.21     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15381    | 0.15381    | 0.15381    |   0.0 |  0.04
Output  | 0.00018853 | 0.00018853 | 0.00018853 |   0.0 |  0.00
Modify  | 0.75688    | 0.75688    | 0.75688    |   0.0 |  0.20
Other   |            | 0.1008     |            |       |  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.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 374.177 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.938 hours/ns, 2.673 timesteps/s
99.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    | 373.17     | 373.17     | 373.17     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15247    | 0.15247    | 0.15247    |   0.0 |  0.04
Output  | 0.0002338  | 0.0002338  | 0.0002338  |   0.0 |  0.00
Modify  | 0.75077    | 0.75077    | 0.75077    |   0.0 |  0.20
Other   |            | 0.1002     |            |       |  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:       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 373.746 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.818 hours/ns, 2.676 timesteps/s
99.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    | 372.73     | 372.73     | 372.73     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15444    | 0.15444    | 0.15444    |   0.0 |  0.04
Output  | 0.00018703 | 0.00018703 | 0.00018703 |   0.0 |  0.00
Modify  | 0.75583    | 0.75583    | 0.75583    |   0.0 |  0.20
Other   |            | 0.1018     |            |       |  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:       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 373.643 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.790 hours/ns, 2.676 timesteps/s
99.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    | 372.64     | 372.64     | 372.64     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15285    | 0.15285    | 0.15285    |   0.0 |  0.04
Output  | 0.00018568 | 0.00018568 | 0.00018568 |   0.0 |  0.00
Modify  | 0.75235    | 0.75235    | 0.75235    |   0.0 |  0.20
Other   |            | 0.09985    |            |       |  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 376.13 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.481 hours/ns, 2.659 timesteps/s
99.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    | 375.12     | 375.12     | 375.12     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1533     | 0.1533     | 0.1533     |   0.0 |  0.04
Output  | 0.00019372 | 0.00019372 | 0.00019372 |   0.0 |  0.00
Modify  | 0.75621    | 0.75621    | 0.75621    |   0.0 |  0.20
Other   |            | 0.1003     |            |       |  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 370.428 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 102.897 hours/ns, 2.700 timesteps/s
99.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    | 369.43     | 369.43     | 369.43     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15117    | 0.15117    | 0.15117    |   0.0 |  0.04
Output  | 0.00019549 | 0.00019549 | 0.00019549 |   0.0 |  0.00
Modify  | 0.74154    | 0.74154    | 0.74154    |   0.0 |  0.20
Other   |            | 0.09996    |            |       |  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 367.666 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.235 ns/day, 102.130 hours/ns, 2.720 timesteps/s
99.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    | 366.68     | 366.68     | 366.68     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15022    | 0.15022    | 0.15022    |   0.0 |  0.04
Output  | 0.00027027 | 0.00027027 | 0.00027027 |   0.0 |  0.00
Modify  | 0.73453    | 0.73453    | 0.73453    |   0.0 |  0.20
Other   |            | 0.09889    |            |       |  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:       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 369.646 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.679 hours/ns, 2.705 timesteps/s
99.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    | 368.66     | 368.66     | 368.66     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15119    | 0.15119    | 0.15119    |   0.0 |  0.04
Output  | 0.00018867 | 0.00018867 | 0.00018867 |   0.0 |  0.00
Modify  | 0.73385    | 0.73385    | 0.73385    |   0.0 |  0.20
Other   |            | 0.09863    |            |       |  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:       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 370.193 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 102.831 hours/ns, 2.701 timesteps/s
99.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    | 369.2      | 369.2      | 369.2      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14884    | 0.14884    | 0.14884    |   0.0 |  0.04
Output  | 0.00018764 | 0.00018764 | 0.00018764 |   0.0 |  0.00
Modify  | 0.74138    | 0.74138    | 0.74138    |   0.0 |  0.20
Other   |            | 0.09955    |            |       |  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:       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 368.084 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.235 ns/day, 102.246 hours/ns, 2.717 timesteps/s
99.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    | 367.1      | 367.1      | 367.1      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14946    | 0.14946    | 0.14946    |   0.0 |  0.04
Output  | 0.00019275 | 0.00019275 | 0.00019275 |   0.0 |  0.00
Modify  | 0.73882    | 0.73882    | 0.73882    |   0.0 |  0.20
Other   |            | 0.09997    |            |       |  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:       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 371.582 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 103.217 hours/ns, 2.691 timesteps/s
99.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    | 370.59     | 370.59     | 370.59     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15096    | 0.15096    | 0.15096    |   0.0 |  0.04
Output  | 0.00029099 | 0.00029099 | 0.00029099 |   0.0 |  0.00
Modify  | 0.74144    | 0.74144    | 0.74144    |   0.0 |  0.20
Other   |            | 0.09908    |            |       |  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:       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 370.58 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 102.939 hours/ns, 2.698 timesteps/s
99.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    | 369.58     | 369.58     | 369.58     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15145    | 0.15145    | 0.15145    |   0.0 |  0.04
Output  | 0.00024203 | 0.00024203 | 0.00024203 |   0.0 |  0.00
Modify  | 0.74716    | 0.74716    | 0.74716    |   0.0 |  0.20
Other   |            | 0.09989    |            |       |  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:       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 370.431 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 102.897 hours/ns, 2.700 timesteps/s
99.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    | 369.44     | 369.44     | 369.44     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15076    | 0.15076    | 0.15076    |   0.0 |  0.04
Output  | 0.00019572 | 0.00019572 | 0.00019572 |   0.0 |  0.00
Modify  | 0.74234    | 0.74234    | 0.74234    |   0.0 |  0.20
Other   |            | 0.09982    |            |       |  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:       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 371.602 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 103.223 hours/ns, 2.691 timesteps/s
99.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    | 370.6      | 370.6      | 370.6      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15142    | 0.15142    | 0.15142    |   0.0 |  0.04
Output  | 0.00019157 | 0.00019157 | 0.00019157 |   0.0 |  0.00
Modify  | 0.74897    | 0.74897    | 0.74897    |   0.0 |  0.20
Other   |            | 0.101      |            |       |  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:       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 375.105 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.196 hours/ns, 2.666 timesteps/s
99.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    | 374.1      | 374.1      | 374.1      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15292    | 0.15292    | 0.15292    |   0.0 |  0.04
Output  | 0.00024204 | 0.00024204 | 0.00024204 |   0.0 |  0.00
Modify  | 0.75561    | 0.75561    | 0.75561    |   0.0 |  0.20
Other   |            | 0.1007     |            |       |  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:       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 370.996 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 103.054 hours/ns, 2.695 timesteps/s
99.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    | 369.99     | 369.99     | 369.99     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1513     | 0.1513     | 0.1513     |   0.0 |  0.04
Output  | 0.00019096 | 0.00019096 | 0.00019096 |   0.0 |  0.00
Modify  | 0.75039    | 0.75039    | 0.75039    |   0.0 |  0.20
Other   |            | 0.1006     |            |       |  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:       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 367.384 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.235 ns/day, 102.051 hours/ns, 2.722 timesteps/s
99.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    | 366.4      | 366.4      | 366.4      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14965    | 0.14965    | 0.14965    |   0.0 |  0.04
Output  | 0.00018808 | 0.00018808 | 0.00018808 |   0.0 |  0.00
Modify  | 0.73529    | 0.73529    | 0.73529    |   0.0 |  0.20
Other   |            | 0.09968    |            |       |  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:       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 369.268 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.574 hours/ns, 2.708 timesteps/s
99.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    | 368.28     | 368.28     | 368.28     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14929    | 0.14929    | 0.14929    |   0.0 |  0.04
Output  | 0.00023331 | 0.00023331 | 0.00023331 |   0.0 |  0.00
Modify  | 0.7357     | 0.7357     | 0.7357     |   0.0 |  0.20
Other   |            | 0.09966    |            |       |  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:       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 369.864 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.740 hours/ns, 2.704 timesteps/s
99.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    | 368.87     | 368.87     | 368.87     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15045    | 0.15045    | 0.15045    |   0.0 |  0.04
Output  | 0.00018782 | 0.00018782 | 0.00018782 |   0.0 |  0.00
Modify  | 0.7454     | 0.7454     | 0.7454     |   0.0 |  0.20
Other   |            | 0.1001     |            |       |  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:       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 373.685 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.801 hours/ns, 2.676 timesteps/s
99.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    | 372.69     | 372.69     | 372.69     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15094    | 0.15094    | 0.15094    |   0.0 |  0.04
Output  | 0.00024183 | 0.00024183 | 0.00024183 |   0.0 |  0.00
Modify  | 0.74848    | 0.74848    | 0.74848    |   0.0 |  0.20
Other   |            | 0.09973    |            |       |  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:       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 374.897 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.138 hours/ns, 2.667 timesteps/s
99.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    | 373.88     | 373.88     | 373.88     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15237    | 0.15237    | 0.15237    |   0.0 |  0.04
Output  | 0.00018729 | 0.00018729 | 0.00018729 |   0.0 |  0.00
Modify  | 0.75974    | 0.75974    | 0.75974    |   0.0 |  0.20
Other   |            | 0.1015     |            |       |  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:       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 371.095 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 103.082 hours/ns, 2.695 timesteps/s
99.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    | 370.1      | 370.1      | 370.1      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15086    | 0.15086    | 0.15086    |   0.0 |  0.04
Output  | 0.00023207 | 0.00023207 | 0.00023207 |   0.0 |  0.00
Modify  | 0.74623    | 0.74623    | 0.74623    |   0.0 |  0.20
Other   |            | 0.1008     |            |       |  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:       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 374.052 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.903 hours/ns, 2.673 timesteps/s
99.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    | 373.05     | 373.05     | 373.05     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15096    | 0.15096    | 0.15096    |   0.0 |  0.04
Output  | 0.00022772 | 0.00022772 | 0.00022772 |   0.0 |  0.00
Modify  | 0.75432    | 0.75432    | 0.75432    |   0.0 |  0.20
Other   |            | 0.1004     |            |       |  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:       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 376.586 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.607 hours/ns, 2.655 timesteps/s
99.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    | 375.57     | 375.57     | 375.57     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15256    | 0.15256    | 0.15256    |   0.0 |  0.04
Output  | 0.00018836 | 0.00018836 | 0.00018836 |   0.0 |  0.00
Modify  | 0.76222    | 0.76222    | 0.76222    |   0.0 |  0.20
Other   |            | 0.1015     |            |       |  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:       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 373.356 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.710 hours/ns, 2.678 timesteps/s
99.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    | 372.35     | 372.35     | 372.35     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15121    | 0.15121    | 0.15121    |   0.0 |  0.04
Output  | 0.000191   | 0.000191   | 0.000191   |   0.0 |  0.00
Modify  | 0.75418    | 0.75418    | 0.75418    |   0.0 |  0.20
Other   |            | 0.1018     |            |       |  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:       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 367.561 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.235 ns/day, 102.100 hours/ns, 2.721 timesteps/s
99.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    | 366.58     | 366.58     | 366.58     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14973    | 0.14973    | 0.14973    |   0.0 |  0.04
Output  | 0.00018928 | 0.00018928 | 0.00018928 |   0.0 |  0.00
Modify  | 0.73338    | 0.73338    | 0.73338    |   0.0 |  0.20
Other   |            | 0.09894    |            |       |  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:       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 369.135 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.537 hours/ns, 2.709 timesteps/s
99.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    | 368.15     | 368.15     | 368.15     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1493     | 0.1493     | 0.1493     |   0.0 |  0.04
Output  | 0.00019035 | 0.00019035 | 0.00019035 |   0.0 |  0.00
Modify  | 0.73595    | 0.73595    | 0.73595    |   0.0 |  0.20
Other   |            | 0.09996    |            |       |  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:       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 365.754 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.236 ns/day, 101.598 hours/ns, 2.734 timesteps/s
99.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    | 364.78     | 364.78     | 364.78     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14903    | 0.14903    | 0.14903    |   0.0 |  0.04
Output  | 0.00048821 | 0.00048821 | 0.00048821 |   0.0 |  0.00
Modify  | 0.72573    | 0.72573    | 0.72573    |   0.0 |  0.20
Other   |            | 0.09931    |            |       |  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:       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 368.026 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.235 ns/day, 102.229 hours/ns, 2.717 timesteps/s
99.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    | 367.03     | 367.03     | 367.03     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15048    | 0.15048    | 0.15048    |   0.0 |  0.04
Output  | 0.00018835 | 0.00018835 | 0.00018835 |   0.0 |  0.00
Modify  | 0.74224    | 0.74224    | 0.74224    |   0.0 |  0.20
Other   |            | 0.09988    |            |       |  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:       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 369.62 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.672 hours/ns, 2.705 timesteps/s
99.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    | 368.63     | 368.63     | 368.63     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15103    | 0.15103    | 0.15103    |   0.0 |  0.04
Output  | 0.00023897 | 0.00023897 | 0.00023897 |   0.0 |  0.00
Modify  | 0.74196    | 0.74196    | 0.74196    |   0.0 |  0.20
Other   |            | 0.0999     |            |       |  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:       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 368.19 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.235 ns/day, 102.275 hours/ns, 2.716 timesteps/s
99.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    | 367.2      | 367.2      | 367.2      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14926    | 0.14926    | 0.14926    |   0.0 |  0.04
Output  | 0.00019039 | 0.00019039 | 0.00019039 |   0.0 |  0.00
Modify  | 0.73756    | 0.73756    | 0.73756    |   0.0 |  0.20
Other   |            | 0.0997     |            |       |  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:       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 364.124 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.145 hours/ns, 2.746 timesteps/s
99.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    | 363.16     | 363.16     | 363.16     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14755    | 0.14755    | 0.14755    |   0.0 |  0.04
Output  | 0.00019487 | 0.00019487 | 0.00019487 |   0.0 |  0.00
Modify  | 0.72208    | 0.72208    | 0.72208    |   0.0 |  0.20
Other   |            | 0.09838    |            |       |  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:       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 366.369 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.236 ns/day, 101.769 hours/ns, 2.729 timesteps/s
99.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    | 365.38     | 365.38     | 365.38     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1484     | 0.1484     | 0.1484     |   0.0 |  0.04
Output  | 0.00018906 | 0.00018906 | 0.00018906 |   0.0 |  0.00
Modify  | 0.73538    | 0.73538    | 0.73538    |   0.0 |  0.20
Other   |            | 0.1001     |            |       |  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:       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 365.767 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.236 ns/day, 101.602 hours/ns, 2.734 timesteps/s
99.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    | 364.78     | 364.78     | 364.78     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14898    | 0.14898    | 0.14898    |   0.0 |  0.04
Output  | 0.00019238 | 0.00019238 | 0.00019238 |   0.0 |  0.00
Modify  | 0.73436    | 0.73436    | 0.73436    |   0.0 |  0.20
Other   |            | 0.09967    |            |       |  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:       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 369.697 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.694 hours/ns, 2.705 timesteps/s
99.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    | 368.7      | 368.7      | 368.7      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15051    | 0.15051    | 0.15051    |   0.0 |  0.04
Output  | 0.00022851 | 0.00022851 | 0.00022851 |   0.0 |  0.00
Modify  | 0.7464     | 0.7464     | 0.7464     |   0.0 |  0.20
Other   |            | 0.1001     |            |       |  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:       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 370.87 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 103.019 hours/ns, 2.696 timesteps/s
99.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    | 369.88     | 369.88     | 369.88     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15035    | 0.15035    | 0.15035    |   0.0 |  0.04
Output  | 0.00019744 | 0.00019744 | 0.00019744 |   0.0 |  0.00
Modify  | 0.74264    | 0.74264    | 0.74264    |   0.0 |  0.20
Other   |            | 0.1002     |            |       |  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:       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 363.994 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.109 hours/ns, 2.747 timesteps/s
99.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    | 363.02     | 363.02     | 363.02     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1482     | 0.1482     | 0.1482     |   0.0 |  0.04
Output  | 0.00018914 | 0.00018914 | 0.00018914 |   0.0 |  0.00
Modify  | 0.72591    | 0.72591    | 0.72591    |   0.0 |  0.20
Other   |            | 0.0985     |            |       |  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:       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 362.796 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.777 hours/ns, 2.756 timesteps/s
99.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    | 361.82     | 361.82     | 361.82     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14803    | 0.14803    | 0.14803    |   0.0 |  0.04
Output  | 0.00019327 | 0.00019327 | 0.00019327 |   0.0 |  0.00
Modify  | 0.72328    | 0.72328    | 0.72328    |   0.0 |  0.20
Other   |            | 0.09962    |            |       |  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:       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 365.258 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.461 hours/ns, 2.738 timesteps/s
99.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    | 364.28     | 364.28     | 364.28     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14806    | 0.14806    | 0.14806    |   0.0 |  0.04
Output  | 0.00023285 | 0.00023285 | 0.00023285 |   0.0 |  0.00
Modify  | 0.73359    | 0.73359    | 0.73359    |   0.0 |  0.20
Other   |            | 0.09999    |            |       |  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:       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 368.758 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.433 hours/ns, 2.712 timesteps/s
99.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    | 367.77     | 367.77     | 367.77     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14998    | 0.14998    | 0.14998    |   0.0 |  0.04
Output  | 0.00023953 | 0.00023953 | 0.00023953 |   0.0 |  0.00
Modify  | 0.73687    | 0.73687    | 0.73687    |   0.0 |  0.20
Other   |            | 0.09929    |            |       |  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:       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 372.081 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.232 ns/day, 103.356 hours/ns, 2.688 timesteps/s
99.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    | 371.07     | 371.07     | 371.07     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15069    | 0.15069    | 0.15069    |   0.0 |  0.04
Output  | 0.00019239 | 0.00019239 | 0.00019239 |   0.0 |  0.00
Modify  | 0.75417    | 0.75417    | 0.75417    |   0.0 |  0.20
Other   |            | 0.1017     |            |       |  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:       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 365.945 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.236 ns/day, 101.651 hours/ns, 2.733 timesteps/s
99.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    | 364.97     | 364.97     | 364.97     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14947    | 0.14947    | 0.14947    |   0.0 |  0.04
Output  | 0.0001923  | 0.0001923  | 0.0001923  |   0.0 |  0.00
Modify  | 0.72981    | 0.72981    | 0.72981    |   0.0 |  0.20
Other   |            | 0.1003     |            |       |  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:       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 372.254 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.232 ns/day, 103.404 hours/ns, 2.686 timesteps/s
99.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    | 371.25     | 371.25     | 371.25     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15098    | 0.15098    | 0.15098    |   0.0 |  0.04
Output  | 0.00019587 | 0.00019587 | 0.00019587 |   0.0 |  0.00
Modify  | 0.75355    | 0.75355    | 0.75355    |   0.0 |  0.20
Other   |            | 0.1017     |            |       |  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:       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 368.135 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.235 ns/day, 102.260 hours/ns, 2.716 timesteps/s
100.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    | 367.15     | 367.15     | 367.15     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1487     | 0.1487     | 0.1487     |   0.0 |  0.04
Output  | 0.00023524 | 0.00023524 | 0.00023524 |   0.0 |  0.00
Modify  | 0.73291    | 0.73291    | 0.73291    |   0.0 |  0.20
Other   |            | 0.1003     |            |       |  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:       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 372.72 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.232 ns/day, 103.533 hours/ns, 2.683 timesteps/s
99.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    | 371.72     | 371.72     | 371.72     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1519     | 0.1519     | 0.1519     |   0.0 |  0.04
Output  | 0.00019101 | 0.00019101 | 0.00019101 |   0.0 |  0.00
Modify  | 0.75044    | 0.75044    | 0.75044    |   0.0 |  0.20
Other   |            | 0.1008     |            |       |  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:       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 368.088 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.235 ns/day, 102.247 hours/ns, 2.717 timesteps/s
99.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    | 367.1      | 367.1      | 367.1      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14955    | 0.14955    | 0.14955    |   0.0 |  0.04
Output  | 0.00023484 | 0.00023484 | 0.00023484 |   0.0 |  0.00
Modify  | 0.73838    | 0.73838    | 0.73838    |   0.0 |  0.20
Other   |            | 0.1001     |            |       |  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:       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 370.324 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 102.868 hours/ns, 2.700 timesteps/s
99.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    | 369.33     | 369.33     | 369.33     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15013    | 0.15013    | 0.15013    |   0.0 |  0.04
Output  | 0.00018992 | 0.00018992 | 0.00018992 |   0.0 |  0.00
Modify  | 0.74283    | 0.74283    | 0.74283    |   0.0 |  0.20
Other   |            | 0.09996    |            |       |  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:       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 370.52 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 102.922 hours/ns, 2.699 timesteps/s
99.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    | 369.53     | 369.53     | 369.53     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14924    | 0.14924    | 0.14924    |   0.0 |  0.04
Output  | 0.00026198 | 0.00026198 | 0.00026198 |   0.0 |  0.00
Modify  | 0.73726    | 0.73726    | 0.73726    |   0.0 |  0.20
Other   |            | 0.09972    |            |       |  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:       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 368.866 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.463 hours/ns, 2.711 timesteps/s
99.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    | 367.88     | 367.88     | 367.88     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14908    | 0.14908    | 0.14908    |   0.0 |  0.04
Output  | 0.0002359  | 0.0002359  | 0.0002359  |   0.0 |  0.00
Modify  | 0.74062    | 0.74062    | 0.74062    |   0.0 |  0.20
Other   |            | 0.09985    |            |       |  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:       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 367.223 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.235 ns/day, 102.006 hours/ns, 2.723 timesteps/s
99.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    | 366.25     | 366.25     | 366.25     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14912    | 0.14912    | 0.14912    |   0.0 |  0.04
Output  | 0.00029729 | 0.00029729 | 0.00029729 |   0.0 |  0.00
Modify  | 0.7288     | 0.7288     | 0.7288     |   0.0 |  0.20
Other   |            | 0.09968    |            |       |  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:       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 362.247 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.239 ns/day, 100.624 hours/ns, 2.761 timesteps/s
99.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    | 361.28     | 361.28     | 361.28     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14711    | 0.14711    | 0.14711    |   0.0 |  0.04
Output  | 0.00026334 | 0.00026334 | 0.00026334 |   0.0 |  0.00
Modify  | 0.7228     | 0.7228     | 0.7228     |   0.0 |  0.20
Other   |            | 0.1004     |            |       |  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:       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 364.727 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.313 hours/ns, 2.742 timesteps/s
100.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    | 363.75     | 363.75     | 363.75     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14986    | 0.14986    | 0.14986    |   0.0 |  0.04
Output  | 0.00023422 | 0.00023422 | 0.00023422 |   0.0 |  0.00
Modify  | 0.72953    | 0.72953    | 0.72953    |   0.0 |  0.20
Other   |            | 0.09991    |            |       |  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:       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 368.838 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.455 hours/ns, 2.711 timesteps/s
100.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    | 367.85     | 367.85     | 367.85     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1495     | 0.1495     | 0.1495     |   0.0 |  0.04
Output  | 0.0001917  | 0.0001917  | 0.0001917  |   0.0 |  0.00
Modify  | 0.73976    | 0.73976    | 0.73976    |   0.0 |  0.20
Other   |            | 0.1006     |            |       |  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:       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 371.511 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 103.197 hours/ns, 2.692 timesteps/s
99.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    | 370.51     | 370.51     | 370.51     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15118    | 0.15118    | 0.15118    |   0.0 |  0.04
Output  | 0.00019261 | 0.00019261 | 0.00019261 |   0.0 |  0.00
Modify  | 0.74902    | 0.74902    | 0.74902    |   0.0 |  0.20
Other   |            | 0.101      |            |       |  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:       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 368.751 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.431 hours/ns, 2.712 timesteps/s
99.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    | 367.76     | 367.76     | 367.76     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1503     | 0.1503     | 0.1503     |   0.0 |  0.04
Output  | 0.00019233 | 0.00019233 | 0.00019233 |   0.0 |  0.00
Modify  | 0.74023    | 0.74023    | 0.74023    |   0.0 |  0.20
Other   |            | 0.1002     |            |       |  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:       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 367.881 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.235 ns/day, 102.189 hours/ns, 2.718 timesteps/s
99.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    | 366.9      | 366.9      | 366.9      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14812    | 0.14812    | 0.14812    |   0.0 |  0.04
Output  | 0.00024124 | 0.00024124 | 0.00024124 |   0.0 |  0.00
Modify  | 0.73228    | 0.73228    | 0.73228    |   0.0 |  0.20
Other   |            | 0.1        |            |       |  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:       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 370.752 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 102.987 hours/ns, 2.697 timesteps/s
99.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    | 369.76     | 369.76     | 369.76     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15005    | 0.15005    | 0.15005    |   0.0 |  0.04
Output  | 0.00018981 | 0.00018981 | 0.00018981 |   0.0 |  0.00
Modify  | 0.74213    | 0.74213    | 0.74213    |   0.0 |  0.20
Other   |            | 0.1005     |            |       |  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:       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 368.984 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.496 hours/ns, 2.710 timesteps/s
99.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    | 368        | 368        | 368        |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14969    | 0.14969    | 0.14969    |   0.0 |  0.04
Output  | 0.00019053 | 0.00019053 | 0.00019053 |   0.0 |  0.00
Modify  | 0.73937    | 0.73937    | 0.73937    |   0.0 |  0.20
Other   |            | 0.09977    |            |       |  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:       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 367.721 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.235 ns/day, 102.145 hours/ns, 2.719 timesteps/s
100.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    | 366.74     | 366.74     | 366.74     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14995    | 0.14995    | 0.14995    |   0.0 |  0.04
Output  | 0.0014103  | 0.0014103  | 0.0014103  |   0.0 |  0.00
Modify  | 0.73491    | 0.73491    | 0.73491    |   0.0 |  0.20
Other   |            | 0.09949    |            |       |  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:       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 372.076 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.232 ns/day, 103.355 hours/ns, 2.688 timesteps/s
99.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    | 371.08     | 371.08     | 371.08     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15031    | 0.15031    | 0.15031    |   0.0 |  0.04
Output  | 0.00022214 | 0.00022214 | 0.00022214 |   0.0 |  0.00
Modify  | 0.74431    | 0.74431    | 0.74431    |   0.0 |  0.20
Other   |            | 0.1001     |            |       |  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:       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 364.003 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.112 hours/ns, 2.747 timesteps/s
99.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    | 363.03     | 363.03     | 363.03     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1477     | 0.1477     | 0.1477     |   0.0 |  0.04
Output  | 0.00019274 | 0.00019274 | 0.00019274 |   0.0 |  0.00
Modify  | 0.72863    | 0.72863    | 0.72863    |   0.0 |  0.20
Other   |            | 0.09935    |            |       |  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:       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 372.705 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.232 ns/day, 103.529 hours/ns, 2.683 timesteps/s
99.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    | 371.71     | 371.71     | 371.71     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15145    | 0.15145    | 0.15145    |   0.0 |  0.04
Output  | 0.00019138 | 0.00019138 | 0.00019138 |   0.0 |  0.00
Modify  | 0.74662    | 0.74662    | 0.74662    |   0.0 |  0.20
Other   |            | 0.1005     |            |       |  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:       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 368.14 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.235 ns/day, 102.261 hours/ns, 2.716 timesteps/s
99.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    | 367.15     | 367.15     | 367.15     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14855    | 0.14855    | 0.14855    |   0.0 |  0.04
Output  | 0.00019224 | 0.00019224 | 0.00019224 |   0.0 |  0.00
Modify  | 0.73742    | 0.73742    | 0.73742    |   0.0 |  0.20
Other   |            | 0.1004     |            |       |  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:       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 366.23 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.236 ns/day, 101.731 hours/ns, 2.731 timesteps/s
99.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    | 365.25     | 365.25     | 365.25     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1484     | 0.1484     | 0.1484     |   0.0 |  0.04
Output  | 0.0001925  | 0.0001925  | 0.0001925  |   0.0 |  0.00
Modify  | 0.73481    | 0.73481    | 0.73481    |   0.0 |  0.20
Other   |            | 0.09958    |            |       |  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:       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 363.093 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.859 hours/ns, 2.754 timesteps/s
100.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    | 362.13     | 362.13     | 362.13     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14751    | 0.14751    | 0.14751    |   0.0 |  0.04
Output  | 0.00019269 | 0.00019269 | 0.00019269 |   0.0 |  0.00
Modify  | 0.72039    | 0.72039    | 0.72039    |   0.0 |  0.20
Other   |            | 0.09883    |            |       |  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:       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 355.13 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.243 ns/day, 98.647 hours/ns, 2.816 timesteps/s
100.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    | 354.19     | 354.19     | 354.19     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14453    | 0.14453    | 0.14453    |   0.0 |  0.04
Output  | 0.00019111 | 0.00019111 | 0.00019111 |   0.0 |  0.00
Modify  | 0.70058    | 0.70058    | 0.70058    |   0.0 |  0.20
Other   |            | 0.09885    |            |       |  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:       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 360.369 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.240 ns/day, 100.102 hours/ns, 2.775 timesteps/s
100.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    | 359.4      | 359.4      | 359.4      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14759    | 0.14759    | 0.14759    |   0.0 |  0.04
Output  | 0.00018949 | 0.00018949 | 0.00018949 |   0.0 |  0.00
Modify  | 0.72362    | 0.72362    | 0.72362    |   0.0 |  0.20
Other   |            | 0.09958    |            |       |  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:       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 358.259 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.241 ns/day, 99.516 hours/ns, 2.791 timesteps/s
100.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    | 357.3      | 357.3      | 357.3      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14783    | 0.14783    | 0.14783    |   0.0 |  0.04
Output  | 0.00018993 | 0.00018993 | 0.00018993 |   0.0 |  0.00
Modify  | 0.71682    | 0.71682    | 0.71682    |   0.0 |  0.20
Other   |            | 0.09846    |            |       |  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:       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 360.498 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.240 ns/day, 100.138 hours/ns, 2.774 timesteps/s
100.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    | 359.54     | 359.54     | 359.54     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14606    | 0.14606    | 0.14606    |   0.0 |  0.04
Output  | 0.00023505 | 0.00023505 | 0.00023505 |   0.0 |  0.00
Modify  | 0.71056    | 0.71056    | 0.71056    |   0.0 |  0.20
Other   |            | 0.09856    |            |       |  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:       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 360.038 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.240 ns/day, 100.011 hours/ns, 2.777 timesteps/s
100.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    | 359.08     | 359.08     | 359.08     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14663    | 0.14663    | 0.14663    |   0.0 |  0.04
Output  | 0.00018966 | 0.00018966 | 0.00018966 |   0.0 |  0.00
Modify  | 0.71613    | 0.71613    | 0.71613    |   0.0 |  0.20
Other   |            | 0.09961    |            |       |  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:       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 362.927 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.813 hours/ns, 2.755 timesteps/s
99.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    | 361.96     | 361.96     | 361.96     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1468     | 0.1468     | 0.1468     |   0.0 |  0.04
Output  | 0.00023311 | 0.00023311 | 0.00023311 |   0.0 |  0.00
Modify  | 0.72047    | 0.72047    | 0.72047    |   0.0 |  0.20
Other   |            | 0.09913    |            |       |  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:       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