# 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.044650763273239*${_u_distance}
variable latticeconst_converted equal 4.044650763273239*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04465076327324
Lattice spacing in x,y,z = 4.0446508 4.0446508 4.0446508
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (40.446508 40.446508 40.446508)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (40.446508 40.446508 40.446508)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Al

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

kim interactions Al
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_DongKimKo_2012_CoAl__MO_099716416216_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.2499448559    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66167.2499448559/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66167.2499448559/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 66167.2499448559/(1*1*${_u_distance})
variable      V0_metal equal 66167.2499448559/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 66167.2499448559*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66167.2499448559 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_099716416216_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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 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.25       66167.25       2779.9252      2779.9252    
      1000  -13075.332     -13075.332     -13255.138     -13255.138      347.8471       347.8471       67710.433      67710.433     -1538.9085     -1538.9085    
Loop time of 57.4833 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.503 ns/day, 15.968 hours/ns, 17.396 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 57.33      | 57.33      | 57.33      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022542   | 0.022542   | 0.022542   |   0.0 |  0.04
Output  | 0.00013215 | 0.00013215 | 0.00013215 |   0.0 |  0.00
Modify  | 0.12018    | 0.12018    | 0.12018    |   0.0 |  0.21
Other   |            | 0.01089    |            |       |  0.02

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

Total # of neighbors = 312000
Ave neighs/atom = 78
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13075.332     -13075.332     -13255.138     -13255.138      347.8471       347.8471       67710.433      67710.433     -1538.9085     -1538.9085    
      2000  -13094.78      -13094.78      -13266.554     -13266.554      332.30904      332.30904      67471.76       67471.76       218.31243      218.31243    
Loop time of 61.1112 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.414 ns/day, 16.975 hours/ns, 16.364 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.96      | 60.96      | 60.96      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021839   | 0.021839   | 0.021839   |   0.0 |  0.04
Output  | 8.1643e-05 | 8.1643e-05 | 8.1643e-05 |   0.0 |  0.00
Modify  | 0.1183     | 0.1183     | 0.1183     |   0.0 |  0.19
Other   |            | 0.01049    |            |       |  0.02

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

Total # of neighbors = 277944
Ave neighs/atom = 69.486
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13094.78      -13094.78      -13266.554     -13266.554      332.30904      332.30904      67471.76       67471.76       218.31243      218.31243    
      3000  -13081.147     -13081.147     -13252.397     -13252.397      331.29504      331.29504      67556.434      67556.434      222.99502      222.99502    
Loop time of 61.2937 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.410 ns/day, 17.026 hours/ns, 16.315 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.143     | 61.143     | 61.143     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021789   | 0.021789   | 0.021789   |   0.0 |  0.04
Output  | 7.1033e-05 | 7.1033e-05 | 7.1033e-05 |   0.0 |  0.00
Modify  | 0.11801    | 0.11801    | 0.11801    |   0.0 |  0.19
Other   |            | 0.01041    |            |       |  0.02

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

Total # of neighbors = 280600
Ave neighs/atom = 70.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 = 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13081.147     -13081.147     -13252.397     -13252.397      331.29504      331.29504      67556.434      67556.434      222.99502      222.99502    
      4000  -13091.546     -13091.546     -13261.599     -13261.599      328.97885      328.97885      67536.983      67536.983     -234.21554     -234.21554    
Loop time of 60.845 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.420 ns/day, 16.901 hours/ns, 16.435 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.695     | 60.695     | 60.695     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021649   | 0.021649   | 0.021649   |   0.0 |  0.04
Output  | 7.2506e-05 | 7.2506e-05 | 7.2506e-05 |   0.0 |  0.00
Modify  | 0.11773    | 0.11773    | 0.11773    |   0.0 |  0.19
Other   |            | 0.01039    |            |       |  0.02

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

Total # of neighbors = 279128
Ave neighs/atom = 69.782
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13091.546     -13091.546     -13261.599     -13261.599      328.97885      328.97885      67536.983      67536.983     -234.21554     -234.21554    
      5000  -13085.409     -13085.409     -13259.522     -13259.522      336.83332      336.83332      67526.848      67526.848      43.342808      43.342808    
Loop time of 61.0203 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.416 ns/day, 16.950 hours/ns, 16.388 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.87      | 60.87      | 60.87      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021585   | 0.021585   | 0.021585   |   0.0 |  0.04
Output  | 4.7549e-05 | 4.7549e-05 | 4.7549e-05 |   0.0 |  0.00
Modify  | 0.11785    | 0.11785    | 0.11785    |   0.0 |  0.19
Other   |            | 0.01038    |            |       |  0.02

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

Total # of neighbors = 279716
Ave neighs/atom = 69.929
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.07676435299, Press = -155.577778647752
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13085.409     -13085.409     -13259.522     -13259.522      336.83332      336.83332      67526.848      67526.848      43.342808      43.342808    
      6000  -13087.077     -13087.077     -13259.932     -13259.932      334.40005      334.40005      67566.148      67566.148     -412.00228     -412.00228    
Loop time of 60.9727 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.417 ns/day, 16.937 hours/ns, 16.401 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.819     | 60.819     | 60.819     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021748   | 0.021748   | 0.021748   |   0.0 |  0.04
Output  | 4.8992e-05 | 4.8992e-05 | 4.8992e-05 |   0.0 |  0.00
Modify  | 0.12144    | 0.12144    | 0.12144    |   0.0 |  0.20
Other   |            | 0.01037    |            |       |  0.02

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

Total # of neighbors = 279662
Ave neighs/atom = 69.9155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.721096282503, Press = 14.8609624886296
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13087.077     -13087.077     -13259.932     -13259.932      334.40005      334.40005      67566.148      67566.148     -412.00228     -412.00228    
      7000  -13088.301     -13088.301     -13260.149     -13260.149      332.4528       332.4528       67451.204      67451.204      832.23765      832.23765    
Loop time of 60.9419 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.418 ns/day, 16.928 hours/ns, 16.409 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.789     | 60.789     | 60.789     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021673   | 0.021673   | 0.021673   |   0.0 |  0.04
Output  | 4.8601e-05 | 4.8601e-05 | 4.8601e-05 |   0.0 |  0.00
Modify  | 0.12125    | 0.12125    | 0.12125    |   0.0 |  0.20
Other   |            | 0.01042    |            |       |  0.02

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

Total # of neighbors = 279358
Ave neighs/atom = 69.8395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.207204837428, Press = -20.0077100176895
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13088.301     -13088.301     -13260.149     -13260.149      332.4528       332.4528       67451.204      67451.204      832.23765      832.23765    
      8000  -13087.107     -13087.107     -13255.957     -13255.957      326.65257      326.65257      67669.13       67669.13      -1389.0262     -1389.0262    
Loop time of 61.1057 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.414 ns/day, 16.974 hours/ns, 16.365 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.952     | 60.952     | 60.952     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02169    | 0.02169    | 0.02169    |   0.0 |  0.04
Output  | 4.9143e-05 | 4.9143e-05 | 4.9143e-05 |   0.0 |  0.00
Modify  | 0.1217     | 0.1217     | 0.1217     |   0.0 |  0.20
Other   |            | 0.01044    |            |       |  0.02

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

Total # of neighbors = 280514
Ave neighs/atom = 70.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.932388236106, Press = 6.96142482293657
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13087.107     -13087.107     -13255.957     -13255.957      326.65257      326.65257      67669.13       67669.13      -1389.0262     -1389.0262    
      9000  -13091.531     -13091.531     -13261.173     -13261.173      328.18288      328.18288      67428.825      67428.825      954.72897      954.72897    
Loop time of 60.9171 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.418 ns/day, 16.921 hours/ns, 16.416 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.763     | 60.763     | 60.763     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021741   | 0.021741   | 0.021741   |   0.0 |  0.04
Output  | 5.4302e-05 | 5.4302e-05 | 5.4302e-05 |   0.0 |  0.00
Modify  | 0.12169    | 0.12169    | 0.12169    |   0.0 |  0.20
Other   |            | 0.01044    |            |       |  0.02

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

Total # of neighbors = 278096
Ave neighs/atom = 69.524
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.691169895623, Press = -1.64761830756691
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13091.531     -13091.531     -13261.173     -13261.173      328.18288      328.18288      67428.825      67428.825      954.72897      954.72897    
     10000  -13086.737     -13086.737     -13259.465     -13259.465      334.15519      334.15519      67589.821      67589.821     -722.64753     -722.64753    
Loop time of 61.1406 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.413 ns/day, 16.983 hours/ns, 16.356 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.987     | 60.987     | 60.987     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0216     | 0.0216     | 0.0216     |   0.0 |  0.04
Output  | 5.2328e-05 | 5.2328e-05 | 5.2328e-05 |   0.0 |  0.00
Modify  | 0.12159    | 0.12159    | 0.12159    |   0.0 |  0.20
Other   |            | 0.01047    |            |       |  0.02

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

Total # of neighbors = 280390
Ave neighs/atom = 70.0975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.429301239889, Press = -1.63277832710793
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13086.737     -13086.737     -13259.465     -13259.465      334.15519      334.15519      67589.821      67589.821     -722.64753     -722.64753    
     11000  -13091.706     -13091.706     -13261.436     -13261.436      328.35509      328.35509      67470.023      67470.023      566.8095       566.8095     
Loop time of 60.9595 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.417 ns/day, 16.933 hours/ns, 16.404 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.806     | 60.806     | 60.806     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02162    | 0.02162    | 0.02162    |   0.0 |  0.04
Output  | 5.4483e-05 | 5.4483e-05 | 5.4483e-05 |   0.0 |  0.00
Modify  | 0.1215     | 0.1215     | 0.1215     |   0.0 |  0.20
Other   |            | 0.01036    |            |       |  0.02

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

Total # of neighbors = 279172
Ave neighs/atom = 69.793
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.409156674063, Press = 1.39601673588233
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13091.706     -13091.706     -13261.436     -13261.436      328.35509      328.35509      67470.023      67470.023      566.8095       566.8095     
     12000  -13087.222     -13087.222     -13259.121     -13259.121      332.55075      332.55075      67574.858      67574.858     -420.90003     -420.90003    
Loop time of 60.8894 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.419 ns/day, 16.914 hours/ns, 16.423 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.735     | 60.735     | 60.735     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021877   | 0.021877   | 0.021877   |   0.0 |  0.04
Output  | 4.786e-05  | 4.786e-05  | 4.786e-05  |   0.0 |  0.00
Modify  | 0.12159    | 0.12159    | 0.12159    |   0.0 |  0.20
Other   |            | 0.01043    |            |       |  0.02

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

Total # of neighbors = 280244
Ave neighs/atom = 70.061
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.171938271613, Press = -3.21810224511898
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13087.222     -13087.222     -13259.121     -13259.121      332.55075      332.55075      67574.858      67574.858     -420.90003     -420.90003    
     13000  -13089.219     -13089.219     -13262.85      -13262.85       335.90109      335.90109      67490.852      67490.852      256.55814      256.55814    
Loop time of 60.986 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.417 ns/day, 16.941 hours/ns, 16.397 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.832     | 60.832     | 60.832     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021703   | 0.021703   | 0.021703   |   0.0 |  0.04
Output  | 5.7949e-05 | 5.7949e-05 | 5.7949e-05 |   0.0 |  0.00
Modify  | 0.12173    | 0.12173    | 0.12173    |   0.0 |  0.20
Other   |            | 0.01038    |            |       |  0.02

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

Total # of neighbors = 279318
Ave neighs/atom = 69.8295
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.233507125082, Press = 4.84645415419879
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13089.219     -13089.219     -13262.85      -13262.85       335.90109      335.90109      67490.852      67490.852      256.55814      256.55814    
     14000  -13086.705     -13086.705     -13259.71      -13259.71       334.68928      334.68928      67534.622      67534.622     -34.332901     -34.332901    
Loop time of 60.9891 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.417 ns/day, 16.941 hours/ns, 16.396 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.836     | 60.836     | 60.836     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021645   | 0.021645   | 0.021645   |   0.0 |  0.04
Output  | 5.9181e-05 | 5.9181e-05 | 5.9181e-05 |   0.0 |  0.00
Modify  | 0.12144    | 0.12144    | 0.12144    |   0.0 |  0.20
Other   |            | 0.01034    |            |       |  0.02

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

Total # of neighbors = 279930
Ave neighs/atom = 69.9825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.168124964728, Press = -6.88487530078437
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13086.705     -13086.705     -13259.71      -13259.71       334.68928      334.68928      67534.622      67534.622     -34.332901     -34.332901    
     15000  -13091.215     -13091.215     -13258.404     -13258.404      323.43754      323.43754      67578.061      67578.061     -589.19041     -589.19041    
Loop time of 61.1103 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.414 ns/day, 16.975 hours/ns, 16.364 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.957     | 60.957     | 60.957     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021538   | 0.021538   | 0.021538   |   0.0 |  0.04
Output  | 5.1878e-05 | 5.1878e-05 | 5.1878e-05 |   0.0 |  0.00
Modify  | 0.12144    | 0.12144    | 0.12144    |   0.0 |  0.20
Other   |            | 0.01034    |            |       |  0.02

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

Total # of neighbors = 279866
Ave neighs/atom = 69.9665
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.262954429644, Press = 2.90649522279679
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13091.215     -13091.215     -13258.404     -13258.404      323.43754      323.43754      67578.061      67578.061     -589.19041     -589.19041    
     16000  -13084.306     -13084.306     -13260.263     -13260.263      340.39955      340.39955      67482.414      67482.414      556.96573      556.96573    
Loop time of 60.9676 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.417 ns/day, 16.935 hours/ns, 16.402 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.814     | 60.814     | 60.814     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02155    | 0.02155    | 0.02155    |   0.0 |  0.04
Output  | 5.0284e-05 | 5.0284e-05 | 5.0284e-05 |   0.0 |  0.00
Modify  | 0.12121    | 0.12121    | 0.12121    |   0.0 |  0.20
Other   |            | 0.01035    |            |       |  0.02

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

Total # of neighbors = 279174
Ave neighs/atom = 69.7935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.251326815479, Press = -0.841499155481908
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13084.306     -13084.306     -13260.263     -13260.263      340.39955      340.39955      67482.414      67482.414      556.96573      556.96573    
     17000  -13091.916     -13091.916     -13262.384     -13262.384      329.78307      329.78307      67587.766      67587.766     -848.97093     -848.97093    
Loop time of 60.9984 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.416 ns/day, 16.944 hours/ns, 16.394 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.845     | 60.845     | 60.845     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0216     | 0.0216     | 0.0216     |   0.0 |  0.04
Output  | 5.4592e-05 | 5.4592e-05 | 5.4592e-05 |   0.0 |  0.00
Modify  | 0.12149    | 0.12149    | 0.12149    |   0.0 |  0.20
Other   |            | 0.01031    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5840 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       280252 ave      280252 max      280252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280252
Ave neighs/atom = 70.063
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.156581543999, Press = 0.150381660819909
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13091.916     -13091.916     -13262.384     -13262.384      329.78307      329.78307      67587.766      67587.766     -848.97093     -848.97093    
     18000  -13086.448     -13086.448     -13260.154     -13260.154      336.0457       336.0457       67465.024      67465.024      709.1495       709.1495     
Loop time of 61.0061 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.416 ns/day, 16.946 hours/ns, 16.392 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.852     | 60.852     | 60.852     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021626   | 0.021626   | 0.021626   |   0.0 |  0.04
Output  | 5.7218e-05 | 5.7218e-05 | 5.7218e-05 |   0.0 |  0.00
Modify  | 0.12156    | 0.12156    | 0.12156    |   0.0 |  0.20
Other   |            | 0.01033    |            |       |  0.02

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

Total # of neighbors = 279308
Ave neighs/atom = 69.827
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.183882677542, Press = 0.704695248476004
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13086.448     -13086.448     -13260.154     -13260.154      336.0457       336.0457       67465.024      67465.024      709.1495       709.1495     
     19000  -13093.368     -13093.368     -13263.814     -13263.814      329.74046      329.74046      67579.805      67579.805     -905.00901     -905.00901    
Loop time of 61.0381 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.416 ns/day, 16.955 hours/ns, 16.383 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.884     | 60.884     | 60.884     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021644   | 0.021644   | 0.021644   |   0.0 |  0.04
Output  | 5.5214e-05 | 5.5214e-05 | 5.5214e-05 |   0.0 |  0.00
Modify  | 0.12164    | 0.12164    | 0.12164    |   0.0 |  0.20
Other   |            | 0.01033    |            |       |  0.02

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

Total # of neighbors = 280434
Ave neighs/atom = 70.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.07019718719, Press = -2.11068558704875
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13093.368     -13093.368     -13263.814     -13263.814      329.74046      329.74046      67579.805      67579.805     -905.00901     -905.00901    
     20000  -13084.849     -13084.849     -13257.992     -13257.992      334.95568      334.95568      67489.934      67489.934      550.78504      550.78504    
Loop time of 61.0033 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.416 ns/day, 16.945 hours/ns, 16.393 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.85      | 60.85      | 60.85      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021595   | 0.021595   | 0.021595   |   0.0 |  0.04
Output  | 5.1828e-05 | 5.1828e-05 | 5.1828e-05 |   0.0 |  0.00
Modify  | 0.12145    | 0.12145    | 0.12145    |   0.0 |  0.20
Other   |            | 0.01032    |            |       |  0.02

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

Total # of neighbors = 279436
Ave neighs/atom = 69.859
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.106187907881, Press = 4.54520201363144
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13084.849     -13084.849     -13257.992     -13257.992      334.95568      334.95568      67489.934      67489.934      550.78504      550.78504    
     21000  -13089.797     -13089.797     -13261.997     -13261.997      333.13235      333.13235      67508.982      67508.982      125.66659      125.66659    
Loop time of 60.8999 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.419 ns/day, 16.917 hours/ns, 16.420 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.746     | 60.746     | 60.746     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02169    | 0.02169    | 0.02169    |   0.0 |  0.04
Output  | 5.2489e-05 | 5.2489e-05 | 5.2489e-05 |   0.0 |  0.00
Modify  | 0.12146    | 0.12146    | 0.12146    |   0.0 |  0.20
Other   |            | 0.01032    |            |       |  0.02

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

Total # of neighbors = 280084
Ave neighs/atom = 70.021
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.067188842881, Press = -2.04361275696057
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13089.797     -13089.797     -13261.997     -13261.997      333.13235      333.13235      67508.982      67508.982      125.66659      125.66659    
     22000  -13088.911     -13088.911     -13263.432     -13263.432      337.6236       337.6236       67562.216      67562.216     -596.46437     -596.46437    
Loop time of 60.9625 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.417 ns/day, 16.934 hours/ns, 16.404 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.809     | 60.809     | 60.809     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021606   | 0.021606   | 0.021606   |   0.0 |  0.04
Output  | 5.6235e-05 | 5.6235e-05 | 5.6235e-05 |   0.0 |  0.00
Modify  | 0.12141    | 0.12141    | 0.12141    |   0.0 |  0.20
Other   |            | 0.01033    |            |       |  0.02

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

Total # of neighbors = 280052
Ave neighs/atom = 70.013
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.198502965754, Press = 0.875584374061556
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13088.911     -13088.911     -13263.432     -13263.432      337.6236       337.6236       67562.216      67562.216     -596.46437     -596.46437    
     23000  -13088.823     -13088.823     -13261.219     -13261.219      333.51103      333.51103      67505.727      67505.727      160.51223      160.51223    
Loop time of 61.0193 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.416 ns/day, 16.950 hours/ns, 16.388 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.866     | 60.866     | 60.866     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021645   | 0.021645   | 0.021645   |   0.0 |  0.04
Output  | 5.5795e-05 | 5.5795e-05 | 5.5795e-05 |   0.0 |  0.00
Modify  | 0.12145    | 0.12145    | 0.12145    |   0.0 |  0.20
Other   |            | 0.01033    |            |       |  0.02

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

Total # of neighbors = 279670
Ave neighs/atom = 69.9175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.31798378554, Press = -0.353719917441795
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13088.823     -13088.823     -13261.219     -13261.219      333.51103      333.51103      67505.727      67505.727      160.51223      160.51223    
     24000  -13092.564     -13092.564     -13264.067     -13264.067      331.78397      331.78397      67576.535      67576.535     -835.76492     -835.76492    
Loop time of 60.9576 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.417 ns/day, 16.933 hours/ns, 16.405 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.804     | 60.804     | 60.804     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021636   | 0.021636   | 0.021636   |   0.0 |  0.04
Output  | 5.7297e-05 | 5.7297e-05 | 5.7297e-05 |   0.0 |  0.00
Modify  | 0.12162    | 0.12162    | 0.12162    |   0.0 |  0.20
Other   |            | 0.01037    |            |       |  0.02

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

Total # of neighbors = 279902
Ave neighs/atom = 69.9755
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.38278800851, Press = -0.0382255470025029
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13092.564     -13092.564     -13264.067     -13264.067      331.78397      331.78397      67576.535      67576.535     -835.76492     -835.76492    
     25000  -13087.599     -13087.599     -13259.85      -13259.85       333.23222      333.23222      67369.857      67369.857      1767.5702      1767.5702    
Loop time of 60.9075 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.419 ns/day, 16.919 hours/ns, 16.418 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.754     | 60.754     | 60.754     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021533   | 0.021533   | 0.021533   |   0.0 |  0.04
Output  | 5.4292e-05 | 5.4292e-05 | 5.4292e-05 |   0.0 |  0.00
Modify  | 0.12142    | 0.12142    | 0.12142    |   0.0 |  0.20
Other   |            | 0.01034    |            |       |  0.02

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

Total # of neighbors = 279708
Ave neighs/atom = 69.927
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.303038201018, Press = 0.938746931062569
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13087.599     -13087.599     -13259.85      -13259.85       333.23222      333.23222      67369.857      67369.857      1767.5702      1767.5702    
     26000  -13091.237     -13091.237     -13260.684     -13260.684      327.8059       327.8059       67607.104      67607.104     -1039.7545     -1039.7545    
Loop time of 60.9706 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.417 ns/day, 16.936 hours/ns, 16.401 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.817     | 60.817     | 60.817     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021627   | 0.021627   | 0.021627   |   0.0 |  0.04
Output  | 5.4101e-05 | 5.4101e-05 | 5.4101e-05 |   0.0 |  0.00
Modify  | 0.1214     | 0.1214     | 0.1214     |   0.0 |  0.20
Other   |            | 0.01031    |            |       |  0.02

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

Total # of neighbors = 280680
Ave neighs/atom = 70.17
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.329713949235, Press = -1.36905593307624
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13091.237     -13091.237     -13260.684     -13260.684      327.8059       327.8059       67607.104      67607.104     -1039.7545     -1039.7545    
     27000  -13083.911     -13083.911     -13255.694     -13255.694      332.32579      332.32579      67488.475      67488.475      799.34006      799.34006    
Loop time of 60.8695 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.419 ns/day, 16.908 hours/ns, 16.429 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.716     | 60.716     | 60.716     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021693   | 0.021693   | 0.021693   |   0.0 |  0.04
Output  | 4.9453e-05 | 4.9453e-05 | 4.9453e-05 |   0.0 |  0.00
Modify  | 0.12136    | 0.12136    | 0.12136    |   0.0 |  0.20
Other   |            | 0.01034    |            |       |  0.02

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

Total # of neighbors = 279046
Ave neighs/atom = 69.7615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.421688749003, Press = 1.35506731453465
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13083.911     -13083.911     -13255.694     -13255.694      332.32579      332.32579      67488.475      67488.475      799.34006      799.34006    
     28000  -13085.197     -13085.197     -13259.108     -13259.108      336.44279      336.44279      67563.808      67563.808     -325.06161     -325.06161    
Loop time of 61.0176 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.416 ns/day, 16.949 hours/ns, 16.389 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.864     | 60.864     | 60.864     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021583   | 0.021583   | 0.021583   |   0.0 |  0.04
Output  | 7.1925e-05 | 7.1925e-05 | 7.1925e-05 |   0.0 |  0.00
Modify  | 0.12134    | 0.12134    | 0.12134    |   0.0 |  0.20
Other   |            | 0.01034    |            |       |  0.02

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

Total # of neighbors = 279988
Ave neighs/atom = 69.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.485767590707, Press = -1.19698265848543
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13085.197     -13085.197     -13259.108     -13259.108      336.44279      336.44279      67563.808      67563.808     -325.06161     -325.06161    
     29000  -13088.037     -13088.037     -13262.787     -13262.787      338.06525      338.06525      67518.061      67518.061     -19.145191     -19.145191    
Loop time of 60.9135 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.418 ns/day, 16.920 hours/ns, 16.417 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.76      | 60.76      | 60.76      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02162    | 0.02162    | 0.02162    |   0.0 |  0.04
Output  | 5.8399e-05 | 5.8399e-05 | 5.8399e-05 |   0.0 |  0.00
Modify  | 0.12145    | 0.12145    | 0.12145    |   0.0 |  0.20
Other   |            | 0.01034    |            |       |  0.02

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

Total # of neighbors = 279374
Ave neighs/atom = 69.8435
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.591906277266, Press = 1.21846136321072
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13088.037     -13088.037     -13262.787     -13262.787      338.06525      338.06525      67518.061      67518.061     -19.145191     -19.145191    
     30000  -13082.297     -13082.297     -13257.016     -13257.016      338.00549      338.00549      67543.39       67543.39       75.465143      75.465143    
Loop time of 60.92 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.418 ns/day, 16.922 hours/ns, 16.415 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.767     | 60.767     | 60.767     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021599   | 0.021599   | 0.021599   |   0.0 |  0.04
Output  | 5.4662e-05 | 5.4662e-05 | 5.4662e-05 |   0.0 |  0.00
Modify  | 0.12141    | 0.12141    | 0.12141    |   0.0 |  0.20
Other   |            | 0.01035    |            |       |  0.02

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

Total # of neighbors = 279738
Ave neighs/atom = 69.9345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.635600440155, Press = -1.46202203406763
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13082.297     -13082.297     -13257.016     -13257.016      338.00549      338.00549      67543.39       67543.39       75.465143      75.465143    
     31000  -13089.946     -13089.946     -13260.305     -13260.305      329.57155      329.57155      67626.734      67626.734     -1138.5617     -1138.5617    
Loop time of 60.8955 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.419 ns/day, 16.915 hours/ns, 16.422 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.742     | 60.742     | 60.742     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021728   | 0.021728   | 0.021728   |   0.0 |  0.04
Output  | 5.3351e-05 | 5.3351e-05 | 5.3351e-05 |   0.0 |  0.00
Modify  | 0.12162    | 0.12162    | 0.12162    |   0.0 |  0.20
Other   |            | 0.01032    |            |       |  0.02

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

Total # of neighbors = 279342
Ave neighs/atom = 69.8355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.686531868827, Press = 2.59586887687498
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13089.946     -13089.946     -13260.305     -13260.305      329.57155      329.57155      67626.734      67626.734     -1138.5617     -1138.5617    
     32000  -13086.064     -13086.064     -13262.491     -13262.491      341.31017      341.31017      67433.3        67433.3        972.67598      972.67598    
Loop time of 60.8681 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.419 ns/day, 16.908 hours/ns, 16.429 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.714     | 60.714     | 60.714     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021738   | 0.021738   | 0.021738   |   0.0 |  0.04
Output  | 5.2208e-05 | 5.2208e-05 | 5.2208e-05 |   0.0 |  0.00
Modify  | 0.1217     | 0.1217     | 0.1217     |   0.0 |  0.20
Other   |            | 0.01035    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5839 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       278952 ave      278952 max      278952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278952
Ave neighs/atom = 69.738
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.691758730102, Press = -0.80225405198801
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13086.064     -13086.064     -13262.491     -13262.491      341.31017      341.31017      67433.3        67433.3        972.67598      972.67598    
     33000  -13084.501     -13084.501     -13255.745     -13255.745      331.28284      331.28284      67633.397      67633.397     -827.77304     -827.77304    
Loop time of 61.0997 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.414 ns/day, 16.972 hours/ns, 16.367 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.947     | 60.947     | 60.947     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021553   | 0.021553   | 0.021553   |   0.0 |  0.04
Output  | 7.1113e-05 | 7.1113e-05 | 7.1113e-05 |   0.0 |  0.00
Modify  | 0.12118    | 0.12118    | 0.12118    |   0.0 |  0.20
Other   |            | 0.01038    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5839 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       280716 ave      280716 max      280716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280716
Ave neighs/atom = 70.179
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.765546133618, Press = 0.268559041180957
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13084.501     -13084.501     -13255.745     -13255.745      331.28284      331.28284      67633.397      67633.397     -827.77304     -827.77304    
     34000  -13086.951     -13086.951     -13259.505     -13259.505      333.81684      333.81684      67460.76       67460.76       833.63945      833.63945    
Loop time of 60.7882 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.421 ns/day, 16.886 hours/ns, 16.451 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.635     | 60.635     | 60.635     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021695   | 0.021695   | 0.021695   |   0.0 |  0.04
Output  | 4.9453e-05 | 4.9453e-05 | 4.9453e-05 |   0.0 |  0.00
Modify  | 0.12121    | 0.12121    | 0.12121    |   0.0 |  0.20
Other   |            | 0.01029    |            |       |  0.02

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

Total # of neighbors = 278680
Ave neighs/atom = 69.67
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.792216562792, Press = 0.178234718772438
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13086.951     -13086.951     -13259.505     -13259.505      333.81684      333.81684      67460.76       67460.76       833.63945      833.63945    
     35000  -13088.412     -13088.412     -13258.464     -13258.464      328.97614      328.97614      67592.226      67592.226     -673.5012      -673.5012     
Loop time of 60.939 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.418 ns/day, 16.927 hours/ns, 16.410 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.785     | 60.785     | 60.785     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021591   | 0.021591   | 0.021591   |   0.0 |  0.04
Output  | 4.8982e-05 | 4.8982e-05 | 4.8982e-05 |   0.0 |  0.00
Modify  | 0.12166    | 0.12166    | 0.12166    |   0.0 |  0.20
Other   |            | 0.01036    |            |       |  0.02

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

Total # of neighbors = 280500
Ave neighs/atom = 70.125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.872739485003, Press = -0.192928471996662
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13088.412     -13088.412     -13258.464     -13258.464      328.97614      328.97614      67592.226      67592.226     -673.5012      -673.5012     
     36000  -13082.171     -13082.171     -13257.023     -13257.023      338.26168      338.26168      67479.678      67479.678      833.54542      833.54542    
Loop time of 60.88 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.419 ns/day, 16.911 hours/ns, 16.426 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.726     | 60.726     | 60.726     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021644   | 0.021644   | 0.021644   |   0.0 |  0.04
Output  | 5.7878e-05 | 5.7878e-05 | 5.7878e-05 |   0.0 |  0.00
Modify  | 0.12158    | 0.12158    | 0.12158    |   0.0 |  0.20
Other   |            | 0.01039    |            |       |  0.02

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

Total # of neighbors = 279338
Ave neighs/atom = 69.8345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.919549855424, Press = 1.14122483540033
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13082.171     -13082.171     -13257.023     -13257.023      338.26168      338.26168      67479.678      67479.678      833.54542      833.54542    
     37000  -13091.501     -13091.501     -13262.197     -13262.197      330.22297      330.22297      67593.669      67593.669     -870.73368     -870.73368    
Loop time of 60.9546 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.417 ns/day, 16.932 hours/ns, 16.406 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.801     | 60.801     | 60.801     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021576   | 0.021576   | 0.021576   |   0.0 |  0.04
Output  | 5.5144e-05 | 5.5144e-05 | 5.5144e-05 |   0.0 |  0.00
Modify  | 0.12144    | 0.12144    | 0.12144    |   0.0 |  0.20
Other   |            | 0.01039    |            |       |  0.02

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

Total # of neighbors = 280034
Ave neighs/atom = 70.0085
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.928732051567, Press = -1.8148817856267
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13091.501     -13091.501     -13262.197     -13262.197      330.22297      330.22297      67593.669      67593.669     -870.73368     -870.73368    
     38000  -13086.321     -13086.321     -13257.308     -13257.308      330.78479      330.78479      67528.192      67528.192      180.43123      180.43123    
Loop time of 60.9382 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.418 ns/day, 16.927 hours/ns, 16.410 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.785     | 60.785     | 60.785     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021569   | 0.021569   | 0.021569   |   0.0 |  0.04
Output  | 0.00013451 | 0.00013451 | 0.00013451 |   0.0 |  0.00
Modify  | 0.12132    | 0.12132    | 0.12132    |   0.0 |  0.20
Other   |            | 0.01037    |            |       |  0.02

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

Total # of neighbors = 279452
Ave neighs/atom = 69.863
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.919775538201, Press = 1.53782100735187
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13086.321     -13086.321     -13257.308     -13257.308      330.78479      330.78479      67528.192      67528.192      180.43123      180.43123    
     39000  -13086.48      -13086.48      -13259.643     -13259.643      334.99564      334.99564      67519.985      67519.985      121.14047      121.14047    
Loop time of 60.8976 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.419 ns/day, 16.916 hours/ns, 16.421 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.744     | 60.744     | 60.744     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021631   | 0.021631   | 0.021631   |   0.0 |  0.04
Output  | 5.6736e-05 | 5.6736e-05 | 5.6736e-05 |   0.0 |  0.00
Modify  | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.20
Other   |            | 0.01036    |            |       |  0.02

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

Total # of neighbors = 279414
Ave neighs/atom = 69.8535
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.907021564669, Press = -0.594544884902704
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13086.48      -13086.48      -13259.643     -13259.643      334.99564      334.99564      67519.985      67519.985      121.14047      121.14047    
     40000  -13088.618     -13088.618     -13258.661     -13258.661      328.95979      328.95979      67548.001      67548.001     -172.27233     -172.27233    
Loop time of 60.9633 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.417 ns/day, 16.934 hours/ns, 16.403 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.81      | 60.81      | 60.81      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021684   | 0.021684   | 0.021684   |   0.0 |  0.04
Output  | 5.6957e-05 | 5.6957e-05 | 5.6957e-05 |   0.0 |  0.00
Modify  | 0.12162    | 0.12162    | 0.12162    |   0.0 |  0.20
Other   |            | 0.01034    |            |       |  0.02

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

Total # of neighbors = 279434
Ave neighs/atom = 69.8585
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.879360000449, Press = 0.851572651297133
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13088.618     -13088.618     -13258.661     -13258.661      328.95979      328.95979      67548.001      67548.001     -172.27233     -172.27233    
     41000  -13092.997     -13092.997     -13262.685     -13262.685      328.27435      328.27435      67458.443      67458.443      517.10288      517.10288    
Loop time of 60.9146 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.418 ns/day, 16.921 hours/ns, 16.416 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.761     | 60.761     | 60.761     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021772   | 0.021772   | 0.021772   |   0.0 |  0.04
Output  | 6.4772e-05 | 6.4772e-05 | 6.4772e-05 |   0.0 |  0.00
Modify  | 0.1214     | 0.1214     | 0.1214     |   0.0 |  0.20
Other   |            | 0.01032    |            |       |  0.02

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

Total # of neighbors = 279552
Ave neighs/atom = 69.888
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.904488922477, Press = -0.464143031749459
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13092.997     -13092.997     -13262.685     -13262.685      328.27435      328.27435      67458.443      67458.443      517.10288      517.10288    
     42000  -13087.081     -13087.081     -13255.086     -13255.086      325.0172       325.0172       67643.53       67643.53      -946.33318     -946.33318    
Loop time of 61.0402 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.415 ns/day, 16.956 hours/ns, 16.383 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.887     | 60.887     | 60.887     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021544   | 0.021544   | 0.021544   |   0.0 |  0.04
Output  | 6.6465e-05 | 6.6465e-05 | 6.6465e-05 |   0.0 |  0.00
Modify  | 0.12126    | 0.12126    | 0.12126    |   0.0 |  0.20
Other   |            | 0.01034    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5840 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       280496 ave      280496 max      280496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280496
Ave neighs/atom = 70.124
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.871282783015, Press = 0.774797763575146
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13087.081     -13087.081     -13255.086     -13255.086      325.0172       325.0172       67643.53       67643.53      -946.33318     -946.33318    
     43000  -13090.113     -13090.113     -13260.785     -13260.785      330.17735      330.17735      67380.212      67380.212      1617.6962      1617.6962    
Loop time of 60.7505 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.422 ns/day, 16.875 hours/ns, 16.461 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.596     | 60.596     | 60.596     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021909   | 0.021909   | 0.021909   |   0.0 |  0.04
Output  | 0.00015554 | 0.00015554 | 0.00015554 |   0.0 |  0.00
Modify  | 0.12187    | 0.12187    | 0.12187    |   0.0 |  0.20
Other   |            | 0.01048    |            |       |  0.02

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

Total # of neighbors = 278720
Ave neighs/atom = 69.68
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.872225355091, Press = -0.00544585492716125
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13090.113     -13090.113     -13260.785     -13260.785      330.17735      330.17735      67380.212      67380.212      1617.6962      1617.6962    
     44000  -13084.932     -13084.932     -13259.054     -13259.054      336.85074      336.85074      67635.735      67635.735     -1169.9377     -1169.9377    
Loop time of 61.0616 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.415 ns/day, 16.962 hours/ns, 16.377 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.907     | 60.907     | 60.907     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022091   | 0.022091   | 0.022091   |   0.0 |  0.04
Output  | 0.00013261 | 0.00013261 | 0.00013261 |   0.0 |  0.00
Modify  | 0.12197    | 0.12197    | 0.12197    |   0.0 |  0.20
Other   |            | 0.01049    |            |       |  0.02

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

Total # of neighbors = 281082
Ave neighs/atom = 70.2705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.875748207983, Press = -0.176116736982764
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13084.932     -13084.932     -13259.054     -13259.054      336.85074      336.85074      67635.735      67635.735     -1169.9377     -1169.9377    
     45000  -13090.092     -13090.092     -13258.073     -13258.073      324.96935      324.96935      67451.877      67451.877      979.96178      979.96178    
Loop time of 60.8261 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.420 ns/day, 16.896 hours/ns, 16.440 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.67      | 60.67      | 60.67      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022768   | 0.022768   | 0.022768   |   0.0 |  0.04
Output  | 5.0424e-05 | 5.0424e-05 | 5.0424e-05 |   0.0 |  0.00
Modify  | 0.12304    | 0.12304    | 0.12304    |   0.0 |  0.20
Other   |            | 0.01066    |            |       |  0.02

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

Total # of neighbors = 278608
Ave neighs/atom = 69.652
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.85354918939, Press = 0.759490306586925
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13090.092     -13090.092     -13258.073     -13258.073      324.96935      324.96935      67451.877      67451.877      979.96178      979.96178    
     46000  -13085.951     -13085.951     -13258.386     -13258.386      333.58727      333.58727      67587.081      67587.081     -501.99957     -501.99957    
Loop time of 61.0555 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.415 ns/day, 16.960 hours/ns, 16.379 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.901     | 60.901     | 60.901     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022072   | 0.022072   | 0.022072   |   0.0 |  0.04
Output  | 5.0665e-05 | 5.0665e-05 | 5.0665e-05 |   0.0 |  0.00
Modify  | 0.12216    | 0.12216    | 0.12216    |   0.0 |  0.20
Other   |            | 0.01053    |            |       |  0.02

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

Total # of neighbors = 280234
Ave neighs/atom = 70.0585
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.824359382452, Press = -0.53870983356591
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13085.951     -13085.951     -13258.386     -13258.386      333.58727      333.58727      67587.081      67587.081     -501.99957     -501.99957    
     47000  -13090.311     -13090.311     -13262.752     -13262.752      333.59909      333.59909      67516.445      67516.445     -59.114305     -59.114305    
Loop time of 60.7538 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.422 ns/day, 16.876 hours/ns, 16.460 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.599     | 60.599     | 60.599     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022264   | 0.022264   | 0.022264   |   0.0 |  0.04
Output  | 6.7717e-05 | 6.7717e-05 | 6.7717e-05 |   0.0 |  0.00
Modify  | 0.12219    | 0.12219    | 0.12219    |   0.0 |  0.20
Other   |            | 0.01058    |            |       |  0.02

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

Total # of neighbors = 278984
Ave neighs/atom = 69.746
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.798939945611, Press = 1.16275540735575
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -13090.311     -13090.311     -13262.752     -13262.752      333.59909      333.59909      67516.445      67516.445     -59.114305     -59.114305    
     48000  -13086.816     -13086.816     -13259.271     -13259.271      333.62574      333.62574      67512.94       67512.94       229.37576      229.37576    
Loop time of 60.9552 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.417 ns/day, 16.932 hours/ns, 16.405 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.799     | 60.799     | 60.799     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022514   | 0.022514   | 0.022514   |   0.0 |  0.04
Output  | 4.9483e-05 | 4.9483e-05 | 4.9483e-05 |   0.0 |  0.00
Modify  | 0.12322    | 0.12322    | 0.12322    |   0.0 |  0.20
Other   |            | 0.01073    |            |       |  0.02

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

Total # of neighbors = 279942
Ave neighs/atom = 69.9855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.81097671329, Press = -0.513510582689135
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -13086.816     -13086.816     -13259.271     -13259.271      333.62574      333.62574      67512.94       67512.94       229.37576      229.37576    
     49000  -13094.141     -13094.141     -13262.874     -13262.874      326.42492      326.42492      67527.597      67527.597     -224.73821     -224.73821    
Loop time of 60.8449 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.420 ns/day, 16.901 hours/ns, 16.435 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.689     | 60.689     | 60.689     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022231   | 0.022231   | 0.022231   |   0.0 |  0.04
Output  | 4.6347e-05 | 4.6347e-05 | 4.6347e-05 |   0.0 |  0.00
Modify  | 0.12269    | 0.12269    | 0.12269    |   0.0 |  0.20
Other   |            | 0.01054    |            |       |  0.02

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

Total # of neighbors = 279730
Ave neighs/atom = 69.9325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.771527619512, Press = 0.851779873596033
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -13094.141     -13094.141     -13262.874     -13262.874      326.42492      326.42492      67527.597      67527.597     -224.73821     -224.73821    
     50000  -13084.415     -13084.415     -13258.937     -13258.937      337.62404      337.62404      67489.186      67489.186      587.26924      587.26924    
Loop time of 61.0039 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.416 ns/day, 16.946 hours/ns, 16.392 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.848     | 60.848     | 60.848     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022394   | 0.022394   | 0.022394   |   0.0 |  0.04
Output  | 4.5926e-05 | 4.5926e-05 | 4.5926e-05 |   0.0 |  0.00
Modify  | 0.12271    | 0.12271    | 0.12271    |   0.0 |  0.20
Other   |            | 0.01061    |            |       |  0.02

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

Total # of neighbors = 280070
Ave neighs/atom = 70.0175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.766989228227, Press = -0.573114139794005
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -13084.415     -13084.415     -13258.937     -13258.937      337.62404      337.62404      67489.186      67489.186      587.26924      587.26924    
     51000  -13086.924     -13086.924     -13260.052     -13260.052      334.92737      334.92737      67676.064      67676.064     -1561.0594     -1561.0594    
Loop time of 61.0315 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.416 ns/day, 16.953 hours/ns, 16.385 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.876     | 60.876     | 60.876     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022242   | 0.022242   | 0.022242   |   0.0 |  0.04
Output  | 0.00010464 | 0.00010464 | 0.00010464 |   0.0 |  0.00
Modify  | 0.12251    | 0.12251    | 0.12251    |   0.0 |  0.20
Other   |            | 0.01052    |            |       |  0.02

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

Total # of neighbors = 280026
Ave neighs/atom = 70.0065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.776111873923, Press = 0.790454028341095
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -13086.924     -13086.924     -13260.052     -13260.052      334.92737      334.92737      67676.064      67676.064     -1561.0594     -1561.0594    
     52000  -13087.29      -13087.29      -13261.076     -13261.076      336.20002      336.20002      67435.461      67435.461      1040.2801      1040.2801    
Loop time of 60.7633 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.422 ns/day, 16.879 hours/ns, 16.457 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.609     | 60.609     | 60.609     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02181    | 0.02181    | 0.02181    |   0.0 |  0.04
Output  | 0.00013464 | 0.00013464 | 0.00013464 |   0.0 |  0.00
Modify  | 0.12184    | 0.12184    | 0.12184    |   0.0 |  0.20
Other   |            | 0.01043    |            |       |  0.02

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

Total # of neighbors = 278414
Ave neighs/atom = 69.6035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.796635713722, Press = 0.0361695966875299
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -13087.29      -13087.29      -13261.076     -13261.076      336.20002      336.20002      67435.461      67435.461      1040.2801      1040.2801    
     53000  -13087.784     -13087.784     -13258.084     -13258.084      329.45792      329.45792      67583.316      67583.316     -510.09251     -510.09251    
Loop time of 61.15 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.413 ns/day, 16.986 hours/ns, 16.353 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.995     | 60.995     | 60.995     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021805   | 0.021805   | 0.021805   |   0.0 |  0.04
Output  | 5.1728e-05 | 5.1728e-05 | 5.1728e-05 |   0.0 |  0.00
Modify  | 0.12232    | 0.12232    | 0.12232    |   0.0 |  0.20
Other   |            | 0.01046    |            |       |  0.02

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

Total # of neighbors = 280430
Ave neighs/atom = 70.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 = 332.831332545778, Press = -0.00140804559959034
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -13087.784     -13087.784     -13258.084     -13258.084      329.45792      329.45792      67583.316      67583.316     -510.09251     -510.09251    
     54000  -13087.014     -13087.014     -13256.331     -13256.331      327.5563       327.5563       67480.227      67480.227      758.38817      758.38817    
Loop time of 61.2193 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.411 ns/day, 17.005 hours/ns, 16.335 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.065     | 61.065     | 61.065     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021561   | 0.021561   | 0.021561   |   0.0 |  0.04
Output  | 4.1378e-05 | 4.1378e-05 | 4.1378e-05 |   0.0 |  0.00
Modify  | 0.12185    | 0.12185    | 0.12185    |   0.0 |  0.20
Other   |            | 0.01034    |            |       |  0.02

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

Total # of neighbors = 279300
Ave neighs/atom = 69.825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.850459977388, Press = 0.502949724811045
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -13087.014     -13087.014     -13256.331     -13256.331      327.5563       327.5563       67480.227      67480.227      758.38817      758.38817    
     55000  -13082.059     -13082.059     -13258.671     -13258.671      341.66664      341.66664      67593.897      67593.897     -538.15149     -538.15149    
Loop time of 61.2868 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.410 ns/day, 17.024 hours/ns, 16.317 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.133     | 61.133     | 61.133     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021578   | 0.021578   | 0.021578   |   0.0 |  0.04
Output  | 4.3972e-05 | 4.3972e-05 | 4.3972e-05 |   0.0 |  0.00
Modify  | 0.12212    | 0.12212    | 0.12212    |   0.0 |  0.20
Other   |            | 0.01031    |            |       |  0.02

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

Total # of neighbors = 279804
Ave neighs/atom = 69.951
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.868033412935, Press = -0.35449835636113
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -13082.059     -13082.059     -13258.671     -13258.671      341.66664      341.66664      67593.897      67593.897     -538.15149     -538.15149    
     56000  -13088.037     -13088.037     -13258.389     -13258.389      329.55784      329.55784      67511.751      67511.751      277.1863       277.1863     
Loop time of 61.2146 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.411 ns/day, 17.004 hours/ns, 16.336 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.06      | 61.06      | 61.06      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021659   | 0.021659   | 0.021659   |   0.0 |  0.04
Output  | 4.4574e-05 | 4.4574e-05 | 4.4574e-05 |   0.0 |  0.00
Modify  | 0.12212    | 0.12212    | 0.12212    |   0.0 |  0.20
Other   |            | 0.01034    |            |       |  0.02

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

Total # of neighbors = 278974
Ave neighs/atom = 69.7435
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.913816966265, Press = 1.16457099743703
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -13088.037     -13088.037     -13258.389     -13258.389      329.55784      329.55784      67511.751      67511.751      277.1863       277.1863     
     57000  -13083.007     -13083.007     -13258.826     -13258.826      340.13273      340.13273      67494.232      67494.232      493.15283      493.15283    
Loop time of 61.2098 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.412 ns/day, 17.003 hours/ns, 16.337 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.056     | 61.056     | 61.056     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021553   | 0.021553   | 0.021553   |   0.0 |  0.04
Output  | 4.804e-05  | 4.804e-05  | 4.804e-05  |   0.0 |  0.00
Modify  | 0.12204    | 0.12204    | 0.12204    |   0.0 |  0.20
Other   |            | 0.01028    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5837 ave        5837 max        5837 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       279392 ave      279392 max      279392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279392
Ave neighs/atom = 69.848
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.930668732986, Press = -1.14913904768401
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -13083.007     -13083.007     -13258.826     -13258.826      340.13273      340.13273      67494.232      67494.232      493.15283      493.15283    
     58000  -13089.53      -13089.53      -13260.262     -13260.262      330.29196      330.29196      67571.35       67571.35      -509.06977     -509.06977    
Loop time of 61.3925 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.407 ns/day, 17.053 hours/ns, 16.289 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.238     | 61.238     | 61.238     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021855   | 0.021855   | 0.021855   |   0.0 |  0.04
Output  | 6.5944e-05 | 6.5944e-05 | 6.5944e-05 |   0.0 |  0.00
Modify  | 0.1224     | 0.1224     | 0.1224     |   0.0 |  0.20
Other   |            | 0.01034    |            |       |  0.02

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

Total # of neighbors = 279892
Ave neighs/atom = 69.973
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.974504600702, Press = 0.699416370599044
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -13089.53      -13089.53      -13260.262     -13260.262      330.29196      330.29196      67571.35       67571.35      -509.06977     -509.06977    
     59000  -13084.816     -13084.816     -13257.361     -13257.361      333.80169      333.80169      67468.566      67468.566      809.12998      809.12998    
Loop time of 61.3007 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.409 ns/day, 17.028 hours/ns, 16.313 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.147     | 61.147     | 61.147     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021558   | 0.021558   | 0.021558   |   0.0 |  0.04
Output  | 4.9613e-05 | 4.9613e-05 | 4.9613e-05 |   0.0 |  0.00
Modify  | 0.12217    | 0.12217    | 0.12217    |   0.0 |  0.20
Other   |            | 0.01036    |            |       |  0.02

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0