# 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_JeongParkDo_2018_PdAl__MO_616482358807_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_616482358807_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.2723 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.509 ns/day, 15.909 hours/ns, 17.460 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.118     | 57.118     | 57.118     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022691   | 0.022691   | 0.022691   |   0.0 |  0.04
Output  | 0.00016965 | 0.00016965 | 0.00016965 |   0.0 |  0.00
Modify  | 0.11998    | 0.11998    | 0.11998    |   0.0 |  0.21
Other   |            | 0.01112    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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.31245      218.31245    
Loop time of 63.0652 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.370 ns/day, 17.518 hours/ns, 15.857 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    | 62.912     | 62.912     | 62.912     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022626   | 0.022626   | 0.022626   |   0.0 |  0.04
Output  | 0.00015674 | 0.00015674 | 0.00015674 |   0.0 |  0.00
Modify  | 0.11945    | 0.11945    | 0.11945    |   0.0 |  0.19
Other   |            | 0.01142    |            |       |  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.31245      218.31245    
      3000  -13081.147     -13081.147     -13252.397     -13252.397      331.29504      331.29504      67556.434      67556.434      222.99509      222.99509    
Loop time of 63.3555 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.364 ns/day, 17.599 hours/ns, 15.784 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    | 63.202     | 63.202     | 63.202     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022585   | 0.022585   | 0.022585   |   0.0 |  0.04
Output  | 8.6002e-05 | 8.6002e-05 | 8.6002e-05 |   0.0 |  0.00
Modify  | 0.11937    | 0.11937    | 0.11937    |   0.0 |  0.19
Other   |            | 0.01097    |            |       |  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.99509      222.99509    
      4000  -13091.546     -13091.546     -13261.599     -13261.599      328.97885      328.97885      67536.983      67536.983     -234.21553     -234.21553    
Loop time of 63.081 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.370 ns/day, 17.523 hours/ns, 15.853 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    | 62.929     | 62.929     | 62.929     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022218   | 0.022218   | 0.022218   |   0.0 |  0.04
Output  | 9.1872e-05 | 9.1872e-05 | 9.1872e-05 |   0.0 |  0.00
Modify  | 0.11911    | 0.11911    | 0.11911    |   0.0 |  0.19
Other   |            | 0.01092    |            |       |  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.21553     -234.21553    
      5000  -13085.409     -13085.409     -13259.522     -13259.522      336.83331      336.83331      67526.848      67526.848      43.342877      43.342877    
Loop time of 63.1665 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.368 ns/day, 17.546 hours/ns, 15.831 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    | 63.016     | 63.016     | 63.016     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021684   | 0.021684   | 0.021684   |   0.0 |  0.03
Output  | 4.9263e-05 | 4.9263e-05 | 4.9263e-05 |   0.0 |  0.00
Modify  | 0.11815    | 0.11815    | 0.11815    |   0.0 |  0.19
Other   |            | 0.01067    |            |       |  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.076764452366, Press = -155.577772283408
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.83331      336.83331      67526.848      67526.848      43.342877      43.342877    
      6000  -13087.077     -13087.077     -13259.932     -13259.932      334.40005      334.40005      67566.148      67566.148     -412.00232     -412.00232    
Loop time of 63.1426 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.368 ns/day, 17.540 hours/ns, 15.837 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    | 62.987     | 62.987     | 62.987     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022455   | 0.022455   | 0.022455   |   0.0 |  0.04
Output  | 5.3731e-05 | 5.3731e-05 | 5.3731e-05 |   0.0 |  0.00
Modify  | 0.12253    | 0.12253    | 0.12253    |   0.0 |  0.19
Other   |            | 0.01086    |            |       |  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.721096295777, Press = 14.8609616309605
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.00232     -412.00232    
      7000  -13088.301     -13088.301     -13260.149     -13260.149      332.45281      332.45281      67451.203      67451.203      832.23778      832.23778    
Loop time of 63.1713 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.368 ns/day, 17.548 hours/ns, 15.830 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 63.017     | 63.017     | 63.017     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021965   | 0.021965   | 0.021965   |   0.0 |  0.03
Output  | 5.3401e-05 | 5.3401e-05 | 5.3401e-05 |   0.0 |  0.00
Modify  | 0.12183    | 0.12183    | 0.12183    |   0.0 |  0.19
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:       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.2072048357, Press = -20.0077084491081
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.45281      332.45281      67451.203      67451.203      832.23778      832.23778    
      8000  -13087.107     -13087.107     -13255.957     -13255.957      326.65257      326.65257      67669.13       67669.13      -1389.0263     -1389.0263    
Loop time of 63.2058 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.367 ns/day, 17.557 hours/ns, 15.821 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    | 63.051     | 63.051     | 63.051     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021966   | 0.021966   | 0.021966   |   0.0 |  0.03
Output  | 5.3e-05    | 5.3e-05    | 5.3e-05    |   0.0 |  0.00
Modify  | 0.12198    | 0.12198    | 0.12198    |   0.0 |  0.19
Other   |            | 0.01078    |            |       |  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.932388222818, Press = 6.96142285487547
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.0263     -1389.0263    
      9000  -13091.531     -13091.531     -13261.172     -13261.172      328.18288      328.18288      67428.825      67428.825      954.72905      954.72905    
Loop time of 62.9588 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.372 ns/day, 17.489 hours/ns, 15.883 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    | 62.804     | 62.804     | 62.804     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022095   | 0.022095   | 0.022095   |   0.0 |  0.04
Output  | 8.502e-05  | 8.502e-05  | 8.502e-05  |   0.0 |  0.00
Modify  | 0.12209    | 0.12209    | 0.12209    |   0.0 |  0.19
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:       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.691169882067, Press = -1.64761690592323
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.172     -13261.172      328.18288      328.18288      67428.825      67428.825      954.72905      954.72905    
     10000  -13086.737     -13086.737     -13259.465     -13259.465      334.1552       334.1552       67589.821      67589.821     -722.64757     -722.64757    
Loop time of 63.2796 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.365 ns/day, 17.578 hours/ns, 15.803 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    | 63.124     | 63.124     | 63.124     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022151   | 0.022151   | 0.022151   |   0.0 |  0.04
Output  | 4.9313e-05 | 4.9313e-05 | 4.9313e-05 |   0.0 |  0.00
Modify  | 0.12245    | 0.12245    | 0.12245    |   0.0 |  0.19
Other   |            | 0.011      |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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.429301139656, Press = -1.63277834921327
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.1552       334.1552       67589.821      67589.821     -722.64757     -722.64757    
     11000  -13091.706     -13091.706     -13261.436     -13261.436      328.35509      328.35509      67470.023      67470.023      566.8094       566.8094     
Loop time of 63.0888 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.369 ns/day, 17.525 hours/ns, 15.851 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    | 62.934     | 62.934     | 62.934     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02192    | 0.02192    | 0.02192    |   0.0 |  0.03
Output  | 0.00012232 | 0.00012232 | 0.00012232 |   0.0 |  0.00
Modify  | 0.12205    | 0.12205    | 0.12205    |   0.0 |  0.19
Other   |            | 0.01093    |            |       |  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.409156854869, Press = 1.39601327590321
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.8094       566.8094     
     12000  -13087.222     -13087.222     -13259.121     -13259.121      332.55076      332.55076      67574.858      67574.858     -420.90115     -420.90115    
Loop time of 63.486 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.361 ns/day, 17.635 hours/ns, 15.751 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    | 63.329     | 63.329     | 63.329     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022334   | 0.022334   | 0.022334   |   0.0 |  0.04
Output  | 0.00016604 | 0.00016604 | 0.00016604 |   0.0 |  0.00
Modify  | 0.12306    | 0.12306    | 0.12306    |   0.0 |  0.19
Other   |            | 0.01111    |            |       |  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.171938319284, Press = -3.21810151000863
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.55076      332.55076      67574.858      67574.858     -420.90115     -420.90115    
     13000  -13089.219     -13089.219     -13262.85      -13262.85       335.90106      335.90106      67490.851      67490.851      256.5616       256.5616     
Loop time of 63.1975 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.367 ns/day, 17.555 hours/ns, 15.823 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    | 63.043     | 63.043     | 63.043     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021993   | 0.021993   | 0.021993   |   0.0 |  0.03
Output  | 0.00014576 | 0.00014576 | 0.00014576 |   0.0 |  0.00
Modify  | 0.12193    | 0.12193    | 0.12193    |   0.0 |  0.19
Other   |            | 0.01083    |            |       |  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.233505499218, Press = 4.84645266646145
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.90106      335.90106      67490.851      67490.851      256.5616       256.5616     
     14000  -13086.705     -13086.705     -13259.71      -13259.71       334.68946      334.68946      67534.623      67534.623     -34.333772     -34.333772    
Loop time of 63.5479 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.360 ns/day, 17.652 hours/ns, 15.736 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    | 63.392     | 63.392     | 63.392     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022082   | 0.022082   | 0.022082   |   0.0 |  0.03
Output  | 4.8972e-05 | 4.8972e-05 | 4.8972e-05 |   0.0 |  0.00
Modify  | 0.12264    | 0.12264    | 0.12264    |   0.0 |  0.19
Other   |            | 0.01097    |            |       |  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.168121553606, Press = -6.88489278715668
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.68946      334.68946      67534.623      67534.623     -34.333772     -34.333772    
     15000  -13091.208     -13091.208     -13258.398     -13258.398      323.44106      323.44106      67578.093      67578.093     -589.10683     -589.10683    
Loop time of 63.3748 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.363 ns/day, 17.604 hours/ns, 15.779 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    | 63.219     | 63.219     | 63.219     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022003   | 0.022003   | 0.022003   |   0.0 |  0.03
Output  | 9.8776e-05 | 9.8776e-05 | 9.8776e-05 |   0.0 |  0.00
Modify  | 0.12231    | 0.12231    | 0.12231    |   0.0 |  0.19
Other   |            | 0.01097    |            |       |  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.262927163699, Press = 2.90772232785346
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.208     -13091.208     -13258.398     -13258.398      323.44106      323.44106      67578.093      67578.093     -589.10683     -589.10683    
     16000  -13084.306     -13084.306     -13260.263     -13260.263      340.40086      340.40086      67482.39       67482.39       557.23825      557.23825    
Loop time of 63.1807 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.368 ns/day, 17.550 hours/ns, 15.828 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    | 63.025     | 63.025     | 63.025     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022089   | 0.022089   | 0.022089   |   0.0 |  0.03
Output  | 5.5345e-05 | 5.5345e-05 | 5.5345e-05 |   0.0 |  0.00
Modify  | 0.12224    | 0.12224    | 0.12224    |   0.0 |  0.19
Other   |            | 0.01088    |            |       |  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.251090801623, Press = -0.838706492872338
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.40086      340.40086      67482.39       67482.39       557.23825      557.23825    
     17000  -13091.93      -13091.93      -13262.393     -13262.393      329.77186      329.77186      67587.526      67587.526     -846.98002     -846.98002    
Loop time of 63.2023 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.367 ns/day, 17.556 hours/ns, 15.822 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    | 63.048     | 63.048     | 63.048     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021923   | 0.021923   | 0.021923   |   0.0 |  0.03
Output  | 9.4478e-05 | 9.4478e-05 | 9.4478e-05 |   0.0 |  0.00
Modify  | 0.1218     | 0.1218     | 0.1218     |   0.0 |  0.19
Other   |            | 0.01094    |            |       |  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:       280254 ave      280254 max      280254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280254
Ave neighs/atom = 70.0635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.156460040058, Press = 0.152761608919976
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.93      -13091.93      -13262.393     -13262.393      329.77186      329.77186      67587.526      67587.526     -846.98002     -846.98002    
     18000  -13086.45      -13086.45      -13260.154     -13260.154      336.04142      336.04142      67465.102      67465.102      708.19322      708.19322    
Loop time of 63.2678 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.366 ns/day, 17.574 hours/ns, 15.806 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    | 63.112     | 63.112     | 63.112     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022229   | 0.022229   | 0.022229   |   0.0 |  0.04
Output  | 5.0525e-05 | 5.0525e-05 | 5.0525e-05 |   0.0 |  0.00
Modify  | 0.12261    | 0.12261    | 0.12261    |   0.0 |  0.19
Other   |            | 0.01106    |            |       |  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:       279310 ave      279310 max      279310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279310
Ave neighs/atom = 69.8275
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.183316200826, Press = 0.700679769178694
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.45      -13086.45      -13260.154     -13260.154      336.04142      336.04142      67465.102      67465.102      708.19322      708.19322    
     19000  -13093.38      -13093.38      -13263.823     -13263.823      329.73213      329.73213      67580.089      67580.089     -908.86446     -908.86446    
Loop time of 63.2817 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.365 ns/day, 17.578 hours/ns, 15.802 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    | 63.127     | 63.127     | 63.127     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021898   | 0.021898   | 0.021898   |   0.0 |  0.03
Output  | 0.00017033 | 0.00017033 | 0.00017033 |   0.0 |  0.00
Modify  | 0.12166    | 0.12166    | 0.12166    |   0.0 |  0.19
Other   |            | 0.01087    |            |       |  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:       280432 ave      280432 max      280432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280432
Ave neighs/atom = 70.108
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.069593022077, Press = -2.11228383032915
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.38      -13093.38      -13263.823     -13263.823      329.73213      329.73213      67580.089      67580.089     -908.86446     -908.86446    
     20000  -13084.82      -13084.82      -13257.963     -13257.963      334.95867      334.95867      67491.353      67491.353      536.73328      536.73328    
Loop time of 63.2524 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.366 ns/day, 17.570 hours/ns, 15.810 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    | 63.097     | 63.097     | 63.097     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021968   | 0.021968   | 0.021968   |   0.0 |  0.03
Output  | 5.6005e-05 | 5.6005e-05 | 5.6005e-05 |   0.0 |  0.00
Modify  | 0.1223     | 0.1223     | 0.1223     |   0.0 |  0.19
Other   |            | 0.01081    |            |       |  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.108703154144, Press = 4.53832425378187
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.82      -13084.82      -13257.963     -13257.963      334.95867      334.95867      67491.353      67491.353      536.73328      536.73328    
     21000  -13085.645     -13085.645     -13259.748     -13259.748      336.81328      336.81328      67521.503      67521.503      176.20187      176.20187    
Loop time of 63.1861 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.367 ns/day, 17.552 hours/ns, 15.826 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    | 63.03      | 63.03      | 63.03      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022242   | 0.022242   | 0.022242   |   0.0 |  0.04
Output  | 5.9902e-05 | 5.9902e-05 | 5.9902e-05 |   0.0 |  0.00
Modify  | 0.12285    | 0.12285    | 0.12285    |   0.0 |  0.19
Other   |            | 0.01093    |            |       |  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:       280072 ave      280072 max      280072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280072
Ave neighs/atom = 70.018
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.089533805207, Press = -1.76578593171145
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13085.645     -13085.645     -13259.748     -13259.748      336.81328      336.81328      67521.503      67521.503      176.20187      176.20187    
     22000  -13082.133     -13082.133     -13259.764     -13259.764      343.63912      343.63912      67596.656      67596.656     -673.3523      -673.3523     
Loop time of 63.2669 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.366 ns/day, 17.574 hours/ns, 15.806 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    | 63.112     | 63.112     | 63.112     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022071   | 0.022071   | 0.022071   |   0.0 |  0.03
Output  | 4.5306e-05 | 4.5306e-05 | 4.5306e-05 |   0.0 |  0.00
Modify  | 0.12219    | 0.12219    | 0.12219    |   0.0 |  0.19
Other   |            | 0.01078    |            |       |  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:       279848 ave      279848 max      279848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279848
Ave neighs/atom = 69.962
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.216780836529, Press = 0.620339786393502
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13082.133     -13082.133     -13259.764     -13259.764      343.63912      343.63912      67596.656      67596.656     -673.3523      -673.3523     
     23000  -13090.024     -13090.024     -13261.912     -13261.912      332.529        332.529        67488.716      67488.716      294.09892      294.09892    
Loop time of 63.1888 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.367 ns/day, 17.552 hours/ns, 15.826 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    | 63.035     | 63.035     | 63.035     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021626   | 0.021626   | 0.021626   |   0.0 |  0.03
Output  | 5.2629e-05 | 5.2629e-05 | 5.2629e-05 |   0.0 |  0.00
Modify  | 0.12122    | 0.12122    | 0.12122    |   0.0 |  0.19
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:       279222 ave      279222 max      279222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279222
Ave neighs/atom = 69.8055
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.317669939594, Press = -0.399322483216235
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13090.024     -13090.024     -13261.912     -13261.912      332.529        332.529        67488.716      67488.716      294.09892      294.09892    
     24000  -13082.931     -13082.931     -13259.036     -13259.036      340.68654      340.68654      67593.17       67593.17      -590.0055      -590.0055     
Loop time of 63.3224 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.364 ns/day, 17.590 hours/ns, 15.792 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    | 63.168     | 63.168     | 63.168     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021854   | 0.021854   | 0.021854   |   0.0 |  0.03
Output  | 5.8971e-05 | 5.8971e-05 | 5.8971e-05 |   0.0 |  0.00
Modify  | 0.12167    | 0.12167    | 0.12167    |   0.0 |  0.19
Other   |            | 0.01086    |            |       |  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:       280046 ave      280046 max      280046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280046
Ave neighs/atom = 70.0115
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.484087523991, Press = 0.338286255621863
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13082.931     -13082.931     -13259.036     -13259.036      340.68654      340.68654      67593.17       67593.17      -590.0055      -590.0055     
     25000  -13088.723     -13088.723     -13260.31      -13260.31       331.94596      331.94596      67413.185      67413.185      1233.9326      1233.9326    
Loop time of 63.2578 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.366 ns/day, 17.572 hours/ns, 15.808 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    | 63.102     | 63.102     | 63.102     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021941   | 0.021941   | 0.021941   |   0.0 |  0.03
Output  | 0.00011987 | 0.00011987 | 0.00011987 |   0.0 |  0.00
Modify  | 0.12236    | 0.12236    | 0.12236    |   0.0 |  0.19
Other   |            | 0.01099    |            |       |  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:       279274 ave      279274 max      279274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279274
Ave neighs/atom = 69.8185
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.570260810803, Press = -0.505115975615763
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13088.723     -13088.723     -13260.31      -13260.31       331.94596      331.94596      67413.185      67413.185      1233.9326      1233.9326    
     26000  -13080.565     -13080.565     -13254.972     -13254.972      337.4008       337.4008       67661.674      67661.674     -1166.2185     -1166.2185    
Loop time of 63.2432 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.366 ns/day, 17.568 hours/ns, 15.812 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    | 63.088     | 63.088     | 63.088     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021914   | 0.021914   | 0.021914   |   0.0 |  0.03
Output  | 4.4854e-05 | 4.4854e-05 | 4.4854e-05 |   0.0 |  0.00
Modify  | 0.12203    | 0.12203    | 0.12203    |   0.0 |  0.19
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:       280396 ave      280396 max      280396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280396
Ave neighs/atom = 70.099
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.636521892873, Press = 0.210013954335378
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13080.565     -13080.565     -13254.972     -13254.972      337.4008       337.4008       67661.674      67661.674     -1166.2185     -1166.2185    
     27000  -13088.626     -13088.626     -13258.695     -13258.695      329.0116       329.0116       67444.421      67444.421      1058.3602      1058.3602    
Loop time of 63.1381 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.368 ns/day, 17.538 hours/ns, 15.838 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    | 62.984     | 62.984     | 62.984     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021835   | 0.021835   | 0.021835   |   0.0 |  0.03
Output  | 5.1236e-05 | 5.1236e-05 | 5.1236e-05 |   0.0 |  0.00
Modify  | 0.12172    | 0.12172    | 0.12172    |   0.0 |  0.19
Other   |            | 0.01076    |            |       |  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:       278316 ave      278316 max      278316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278316
Ave neighs/atom = 69.579
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.743122233363, Press = 0.701454225830183
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13088.626     -13088.626     -13258.695     -13258.695      329.0116       329.0116       67444.421      67444.421      1058.3602      1058.3602    
     28000  -13083.343     -13083.343     -13257.571     -13257.571      337.05557      337.05557      67613.382      67613.382     -762.43643     -762.43643    
Loop time of 63.471 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.361 ns/day, 17.631 hours/ns, 15.755 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    | 63.316     | 63.316     | 63.316     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022098   | 0.022098   | 0.022098   |   0.0 |  0.03
Output  | 4.4724e-05 | 4.4724e-05 | 4.4724e-05 |   0.0 |  0.00
Modify  | 0.12239    | 0.12239    | 0.12239    |   0.0 |  0.19
Other   |            | 0.01083    |            |       |  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:       280588 ave      280588 max      280588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280588
Ave neighs/atom = 70.147
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.807702740821, Press = -1.32052272790332
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13083.343     -13083.343     -13257.571     -13257.571      337.05557      337.05557      67613.382      67613.382     -762.43643     -762.43643    
     29000  -13088.798     -13088.798     -13262.816     -13262.816      336.64961      336.64961      67494.147      67494.147      232.52475      232.52475    
Loop time of 63.3657 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.364 ns/day, 17.602 hours/ns, 15.781 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    | 63.211     | 63.211     | 63.211     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022023   | 0.022023   | 0.022023   |   0.0 |  0.03
Output  | 0.00011226 | 0.00011226 | 0.00011226 |   0.0 |  0.00
Modify  | 0.12217    | 0.12217    | 0.12217    |   0.0 |  0.19
Other   |            | 0.01084    |            |       |  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:       278942 ave      278942 max      278942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278942
Ave neighs/atom = 69.7355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.761434319791, Press = 1.55781882656991
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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.798     -13088.798     -13262.816     -13262.816      336.64961      336.64961      67494.147      67494.147      232.52475      232.52475    
     30000  -13089.34      -13089.34      -13260.85      -13260.85       331.79628      331.79628      67520.045      67520.045     -1.8987488     -1.8987488    
Loop time of 63.3642 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.364 ns/day, 17.601 hours/ns, 15.782 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    | 63.209     | 63.209     | 63.209     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022006   | 0.022006   | 0.022006   |   0.0 |  0.03
Output  | 5.2088e-05 | 5.2088e-05 | 5.2088e-05 |   0.0 |  0.00
Modify  | 0.12192    | 0.12192    | 0.12192    |   0.0 |  0.19
Other   |            | 0.01092    |            |       |  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:       279928 ave      279928 max      279928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279928
Ave neighs/atom = 69.982
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.808687803593, Press = -1.23239634557342
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13089.34      -13089.34      -13260.85      -13260.85       331.79628      331.79628      67520.045      67520.045     -1.8987488     -1.8987488    
     31000  -13088.575     -13088.575     -13258.958     -13258.958      329.61702      329.61702      67547.775      67547.775     -123.16397     -123.16397    
Loop time of 63.4175 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.362 ns/day, 17.616 hours/ns, 15.769 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    | 63.262     | 63.262     | 63.262     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022239   | 0.022239   | 0.022239   |   0.0 |  0.04
Output  | 0.00013409 | 0.00013409 | 0.00013409 |   0.0 |  0.00
Modify  | 0.12255    | 0.12255    | 0.12255    |   0.0 |  0.19
Other   |            | 0.01098    |            |       |  0.02

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

Total # of neighbors = 279684
Ave neighs/atom = 69.921
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.831926360529, Press = 0.703924847058994
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13088.575     -13088.575     -13258.958     -13258.958      329.61702      329.61702      67547.775      67547.775     -123.16397     -123.16397    
     32000  -13084.293     -13084.293     -13259.377     -13259.377      338.71302      338.71302      67502.264      67502.264      395.50108      395.50108    
Loop time of 63.2453 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.366 ns/day, 17.568 hours/ns, 15.811 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    | 63.092     | 63.092     | 63.092     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021631   | 0.021631   | 0.021631   |   0.0 |  0.03
Output  | 4.5355e-05 | 4.5355e-05 | 4.5355e-05 |   0.0 |  0.00
Modify  | 0.12132    | 0.12132    | 0.12132    |   0.0 |  0.19
Other   |            | 0.01056    |            |       |  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:       279678 ave      279678 max      279678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279678
Ave neighs/atom = 69.9195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.921233010289, Press = -0.59137448818497
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13084.293     -13084.293     -13259.377     -13259.377      338.71302      338.71302      67502.264      67502.264      395.50108      395.50108    
     33000  -13085.273     -13085.273     -13257.584     -13257.584      333.34736      333.34736      67620.782      67620.782     -841.76818     -841.76818    
Loop time of 63.3348 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.364 ns/day, 17.593 hours/ns, 15.789 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    | 63.18      | 63.18      | 63.18      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02186    | 0.02186    | 0.02186    |   0.0 |  0.03
Output  | 4.3361e-05 | 4.3361e-05 | 4.3361e-05 |   0.0 |  0.00
Modify  | 0.12174    | 0.12174    | 0.12174    |   0.0 |  0.19
Other   |            | 0.01082    |            |       |  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:       279968 ave      279968 max      279968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279968
Ave neighs/atom = 69.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.964830333705, Press = 0.621644061960965
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13085.273     -13085.273     -13257.584     -13257.584      333.34736      333.34736      67620.782      67620.782     -841.76818     -841.76818    
     34000  -13091.565     -13091.565     -13262.122     -13262.122      329.95492      329.95492      67345.028      67345.028      1937.1428      1937.1428    
Loop time of 63.6374 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.358 ns/day, 17.677 hours/ns, 15.714 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    | 63.481     | 63.481     | 63.481     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022077   | 0.022077   | 0.022077   |   0.0 |  0.03
Output  | 5.3451e-05 | 5.3451e-05 | 5.3451e-05 |   0.0 |  0.00
Modify  | 0.12302    | 0.12302    | 0.12302    |   0.0 |  0.19
Other   |            | 0.01105    |            |       |  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:       278766 ave      278766 max      278766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278766
Ave neighs/atom = 69.6915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.996423380275, Press = -0.388814389286775
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13091.565     -13091.565     -13262.122     -13262.122      329.95492      329.95492      67345.028      67345.028      1937.1428      1937.1428    
     35000  -13084.543     -13084.543     -13256.605     -13256.605      332.86486      332.86486      67641.817      67641.817     -1029.7948     -1029.7948    
Loop time of 63.8491 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.353 ns/day, 17.736 hours/ns, 15.662 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    | 63.695     | 63.695     | 63.695     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021904   | 0.021904   | 0.021904   |   0.0 |  0.03
Output  | 5.4092e-05 | 5.4092e-05 | 5.4092e-05 |   0.0 |  0.00
Modify  | 0.12213    | 0.12213    | 0.12213    |   0.0 |  0.19
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:       281226 ave      281226 max      281226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281226
Ave neighs/atom = 70.3065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.928682794358, Press = -0.373250297718511
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13084.543     -13084.543     -13256.605     -13256.605      332.86486      332.86486      67641.817      67641.817     -1029.7948     -1029.7948    
     36000  -13093.116     -13093.116     -13262.222     -13262.222      327.14705      327.14705      67467.611      67467.611      493.84062      493.84062    
Loop time of 63.5747 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.359 ns/day, 17.660 hours/ns, 15.730 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    | 63.42      | 63.42      | 63.42      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021791   | 0.021791   | 0.021791   |   0.0 |  0.03
Output  | 5.313e-05  | 5.313e-05  | 5.313e-05  |   0.0 |  0.00
Modify  | 0.122      | 0.122      | 0.122      |   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:       278586 ave      278586 max      278586 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278586
Ave neighs/atom = 69.6465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.910875205626, Press = 0.431453300737081
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13093.116     -13093.116     -13262.222     -13262.222      327.14705      327.14705      67467.611      67467.611      493.84062      493.84062    
     37000  -13085.822     -13085.822     -13257.814     -13257.814      332.73074      332.73074      67561.098      67561.098     -205.45335     -205.45335    
Loop time of 63.9759 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.351 ns/day, 17.771 hours/ns, 15.631 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    | 63.82      | 63.82      | 63.82      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02198    | 0.02198    | 0.02198    |   0.0 |  0.03
Output  | 6.1746e-05 | 6.1746e-05 | 6.1746e-05 |   0.0 |  0.00
Modify  | 0.1229     | 0.1229     | 0.1229     |   0.0 |  0.19
Other   |            | 0.01068    |            |       |  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:       280272 ave      280272 max      280272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280272
Ave neighs/atom = 70.068
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.867992240755, Press = -0.528023019569738
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13085.822     -13085.822     -13257.814     -13257.814      332.73074      332.73074      67561.098      67561.098     -205.45335     -205.45335    
     38000  -13090.332     -13090.332     -13260.901     -13260.901      329.97904      329.97904      67515.083      67515.083      118.44666      118.44666    
Loop time of 63.6208 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.358 ns/day, 17.672 hours/ns, 15.718 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    | 63.466     | 63.466     | 63.466     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022033   | 0.022033   | 0.022033   |   0.0 |  0.03
Output  | 9.1442e-05 | 9.1442e-05 | 9.1442e-05 |   0.0 |  0.00
Modify  | 0.12242    | 0.12242    | 0.12242    |   0.0 |  0.19
Other   |            | 0.01072    |            |       |  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:       279278 ave      279278 max      279278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279278
Ave neighs/atom = 69.8195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.840537136557, Press = 0.717420765459983
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13090.332     -13090.332     -13260.901     -13260.901      329.97904      329.97904      67515.083      67515.083      118.44666      118.44666    
     39000  -13088.009     -13088.009     -13257.713     -13257.713      328.30448      328.30448      67532.366      67532.366      140.2784       140.2784     
Loop time of 63.7242 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.356 ns/day, 17.701 hours/ns, 15.693 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    | 63.57      | 63.57      | 63.57      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021817   | 0.021817   | 0.021817   |   0.0 |  0.03
Output  | 5.6596e-05 | 5.6596e-05 | 5.6596e-05 |   0.0 |  0.00
Modify  | 0.12199    | 0.12199    | 0.12199    |   0.0 |  0.19
Other   |            | 0.01058    |            |       |  0.02

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

Total # of neighbors = 279808
Ave neighs/atom = 69.952
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.879641823077, Press = -0.94816960459385
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13088.009     -13088.009     -13257.713     -13257.713      328.30448      328.30448      67532.366      67532.366      140.2784       140.2784     
     40000  -13081.412     -13081.412     -13256.616     -13256.616      338.94333      338.94333      67617.655      67617.655     -683.29075     -683.29075    
Loop time of 63.5866 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.359 ns/day, 17.663 hours/ns, 15.727 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    | 63.433     | 63.433     | 63.433     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02168    | 0.02168    | 0.02168    |   0.0 |  0.03
Output  | 5.318e-05  | 5.318e-05  | 5.318e-05  |   0.0 |  0.00
Modify  | 0.12179    | 0.12179    | 0.12179    |   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:           5836 ave        5836 max        5836 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       279740 ave      279740 max      279740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279740
Ave neighs/atom = 69.935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.907331609466, Press = 1.15675057384392
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13081.412     -13081.412     -13256.616     -13256.616      338.94333      338.94333      67617.655      67617.655     -683.29075     -683.29075    
     41000  -13087.416     -13087.416     -13258.526     -13258.526      331.02353      331.02353      67444.33       67444.33       1046.2411      1046.2411    
Loop time of 63.9537 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.351 ns/day, 17.765 hours/ns, 15.636 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    | 63.797     | 63.797     | 63.797     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022215   | 0.022215   | 0.022215   |   0.0 |  0.03
Output  | 4.1007e-05 | 4.1007e-05 | 4.1007e-05 |   0.0 |  0.00
Modify  | 0.12336    | 0.12336    | 0.12336    |   0.0 |  0.19
Other   |            | 0.01063    |            |       |  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:       279032 ave      279032 max      279032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279032
Ave neighs/atom = 69.758
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.912576942836, Press = -0.725093322244375
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13087.416     -13087.416     -13258.526     -13258.526      331.02353      331.02353      67444.33       67444.33       1046.2411      1046.2411    
     42000  -13090.41      -13090.41      -13263.2       -13263.2        334.27408      334.27408      67572.834      67572.834     -690.32313     -690.32313    
Loop time of 64.482 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.340 ns/day, 17.912 hours/ns, 15.508 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    | 64.315     | 64.315     | 64.315     |   0.0 | 99.74
Neigh   | 0.011576   | 0.011576   | 0.011576   |   0.0 |  0.02
Comm    | 0.022346   | 0.022346   | 0.022346   |   0.0 |  0.03
Output  | 4.3351e-05 | 4.3351e-05 | 4.3351e-05 |   0.0 |  0.00
Modify  | 0.1226     | 0.1226     | 0.1226     |   0.0 |  0.19
Other   |            | 0.01075    |            |       |  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 = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.93998981913, Press = 0.0113341522843428
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -13090.41      -13090.41      -13263.2       -13263.2        334.27408      334.27408      67572.834      67572.834     -690.32313     -690.32313    
     43000  -13089.644     -13089.644     -13260.955     -13260.955      331.41385      331.41385      67489.394      67489.394      327.11488      327.11488    
Loop time of 63.6594 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.357 ns/day, 17.683 hours/ns, 15.709 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    | 63.505     | 63.505     | 63.505     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021778   | 0.021778   | 0.021778   |   0.0 |  0.03
Output  | 3.9404e-05 | 3.9404e-05 | 3.9404e-05 |   0.0 |  0.00
Modify  | 0.12222    | 0.12222    | 0.12222    |   0.0 |  0.19
Other   |            | 0.01062    |            |       |  0.02

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0