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

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

kim_interactions Ni

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

kim interactions Ni
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_MahataMukhopadhyayAsleZaeem_2022_AlNi__MO_461927113651_001
pair_coeff * * Ni
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 58.6934

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43665.9614516893 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 313.15*${_u_temperature}
variable temp_converted equal 313.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 313.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 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.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  "313.15 - 0.2"
variable      T_up  equal  "313.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_461927113651_001#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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -17638.129     -17638.129     -17800         -17800          313.15         313.15         43665.961      43665.961      3959.5595      3959.5595    
      1000  -17465.764     -17465.764     -17626.68      -17626.68       311.30453      311.30453      44052.444      44052.444      2556.2353      2556.2353    
Loop time of 364.243 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.237 ns/day, 101.179 hours/ns, 2.745 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 363.3      | 363.3      | 363.3      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15277    | 0.15277    | 0.15277    |   0.0 |  0.04
Output  | 0.00027009 | 0.00027009 | 0.00027009 |   0.0 |  0.00
Modify  | 0.69421    | 0.69421    | 0.69421    |   0.0 |  0.19
Other   |            | 0.09755    |            |       |  0.03

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

Total # of neighbors = 344000
Ave neighs/atom = 86
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -17465.764     -17465.764     -17626.68      -17626.68       311.30453      311.30453      44052.444      44052.444      2556.2353      2556.2353    
      2000  -17474.738     -17474.738     -17642.479     -17642.479      324.50543      324.50543      44081.293      44081.293      259.4463       259.4463     
Loop time of 391.4 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.722 hours/ns, 2.555 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 390.42     | 390.42     | 390.42     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15523    | 0.15523    | 0.15523    |   0.0 |  0.04
Output  | 0.000233   | 0.000233   | 0.000233   |   0.0 |  0.00
Modify  | 0.72537    | 0.72537    | 0.72537    |   0.0 |  0.19
Other   |            | 0.1003     |            |       |  0.03

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

Total # of neighbors = 341988
Ave neighs/atom = 85.497
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -17474.738     -17474.738     -17642.479     -17642.479      324.50543      324.50543      44081.293      44081.293      259.4463       259.4463     
      3000  -17474.643     -17474.643     -17638.858     -17638.858      317.68532      317.68532      44088.739      44088.739      238.4365       238.4365     
Loop time of 394.366 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.546 hours/ns, 2.536 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 393.37     | 393.37     | 393.37     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15725    | 0.15725    | 0.15725    |   0.0 |  0.04
Output  | 0.00022959 | 0.00022959 | 0.00022959 |   0.0 |  0.00
Modify  | 0.73505    | 0.73505    | 0.73505    |   0.0 |  0.19
Other   |            | 0.09994    |            |       |  0.03

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

Total # of neighbors = 342096
Ave neighs/atom = 85.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 = 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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -17474.643     -17474.643     -17638.858     -17638.858      317.68532      317.68532      44088.739      44088.739      238.4365       238.4365     
      4000  -17472.071     -17472.071     -17631.864     -17631.864      309.13024      309.13024      44098.239      44098.239      269.88887      269.88887    
Loop time of 392.617 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.060 hours/ns, 2.547 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 391.63     | 391.63     | 391.63     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15638    | 0.15638    | 0.15638    |   0.0 |  0.04
Output  | 0.00023554 | 0.00023554 | 0.00023554 |   0.0 |  0.00
Modify  | 0.72918    | 0.72918    | 0.72918    |   0.0 |  0.19
Other   |            | 0.1007     |            |       |  0.03

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

Total # of neighbors = 342106
Ave neighs/atom = 85.5265
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -17472.071     -17472.071     -17631.864     -17631.864      309.13024      309.13024      44098.239      44098.239      269.88887      269.88887    
      5000  -17476.892     -17476.892     -17636.878     -17636.878      309.50361      309.50361      44103.919      44103.919     -337.90802     -337.90802    
Loop time of 395.003 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.723 hours/ns, 2.532 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 394        | 394        | 394        |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15772    | 0.15772    | 0.15772    |   0.0 |  0.04
Output  | 0.00023376 | 0.00023376 | 0.00023376 |   0.0 |  0.00
Modify  | 0.74098    | 0.74098    | 0.74098    |   0.0 |  0.19
Other   |            | 0.1021     |            |       |  0.03

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

Total # of neighbors = 342080
Ave neighs/atom = 85.52
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.334814085219, Press = -449.910129443835
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -17476.892     -17476.892     -17636.878     -17636.878      309.50361      309.50361      44103.919      44103.919     -337.90802     -337.90802    
      6000  -17470.995     -17470.995     -17635.087     -17635.087      317.4472       317.4472       44133.561      44133.561     -1355.3036     -1355.3036    
Loop time of 391.175 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.660 hours/ns, 2.556 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 390.16     | 390.16     | 390.16     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15599    | 0.15599    | 0.15599    |   0.0 |  0.04
Output  | 0.00018853 | 0.00018853 | 0.00018853 |   0.0 |  0.00
Modify  | 0.75967    | 0.75967    | 0.75967    |   0.0 |  0.19
Other   |            | 0.1016     |            |       |  0.03

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

Total # of neighbors = 342112
Ave neighs/atom = 85.528
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.744945779124, Press = -43.4953302603563
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -17470.995     -17470.995     -17635.087     -17635.087      317.4472       317.4472       44133.561      44133.561     -1355.3036     -1355.3036    
      7000  -17476.243     -17476.243     -17639.296     -17639.296      315.43779      315.43779      44154.118      44154.118     -2550.732      -2550.732     
Loop time of 396.201 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 110.056 hours/ns, 2.524 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 395.18     | 395.18     | 395.18     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15731    | 0.15731    | 0.15731    |   0.0 |  0.04
Output  | 0.00018918 | 0.00018918 | 0.00018918 |   0.0 |  0.00
Modify  | 0.76147    | 0.76147    | 0.76147    |   0.0 |  0.19
Other   |            | 0.1011     |            |       |  0.03

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

Total # of neighbors = 341910
Ave neighs/atom = 85.4775
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.964864081424, Press = -22.0307124675528
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -17476.243     -17476.243     -17639.296     -17639.296      315.43779      315.43779      44154.118      44154.118     -2550.732      -2550.732     
      8000  -17473.697     -17473.697     -17636.006     -17636.006      313.99789      313.99789      44160.62       44160.62      -2547.4124     -2547.4124    
Loop time of 392.941 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.150 hours/ns, 2.545 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 391.93     | 391.93     | 391.93     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15621    | 0.15621    | 0.15621    |   0.0 |  0.04
Output  | 0.00026371 | 0.00026371 | 0.00026371 |   0.0 |  0.00
Modify  | 0.75508    | 0.75508    | 0.75508    |   0.0 |  0.19
Other   |            | 0.09997    |            |       |  0.03

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

Total # of neighbors = 342032
Ave neighs/atom = 85.508
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.921084556763, Press = -6.36469670046108
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -17473.697     -17473.697     -17636.006     -17636.006      313.99789      313.99789      44160.62       44160.62      -2547.4124     -2547.4124    
      9000  -17471.856     -17471.856     -17631.547     -17631.547      308.93263      308.93263      44128.474      44128.474     -876.84115     -876.84115    
Loop time of 390.059 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.350 hours/ns, 2.564 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 389.05     | 389.05     | 389.05     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15529    | 0.15529    | 0.15529    |   0.0 |  0.04
Output  | 0.00026003 | 0.00026003 | 0.00026003 |   0.0 |  0.00
Modify  | 0.74997    | 0.74997    | 0.74997    |   0.0 |  0.19
Other   |            | 0.1003     |            |       |  0.03

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

Total # of neighbors = 341914
Ave neighs/atom = 85.4785
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.590473817633, Press = 1.11489705989299
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -17471.856     -17471.856     -17631.547     -17631.547      308.93263      308.93263      44128.474      44128.474     -876.84115     -876.84115    
     10000  -17474.768     -17474.768     -17638.548     -17638.548      316.84456      316.84456      44114.562      44114.562     -865.36691     -865.36691    
Loop time of 394.554 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.598 hours/ns, 2.535 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 393.53     | 393.53     | 393.53     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15756    | 0.15756    | 0.15756    |   0.0 |  0.04
Output  | 0.00026059 | 0.00026059 | 0.00026059 |   0.0 |  0.00
Modify  | 0.76205    | 0.76205    | 0.76205    |   0.0 |  0.19
Other   |            | 0.1007     |            |       |  0.03

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

Total # of neighbors = 342048
Ave neighs/atom = 85.512
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.90582011932, Press = -0.687681626456988
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -17474.768     -17474.768     -17638.548     -17638.548      316.84456      316.84456      44114.562      44114.562     -865.36691     -865.36691    
     11000  -17471.624     -17471.624     -17632.505     -17632.505      311.23591      311.23591      44112.333      44112.333     -262.36242     -262.36242    
Loop time of 388.879 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.022 hours/ns, 2.571 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 387.87     | 387.87     | 387.87     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15636    | 0.15636    | 0.15636    |   0.0 |  0.04
Output  | 0.00023536 | 0.00023536 | 0.00023536 |   0.0 |  0.00
Modify  | 0.75025    | 0.75025    | 0.75025    |   0.0 |  0.19
Other   |            | 0.1006     |            |       |  0.03

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

Total # of neighbors = 342196
Ave neighs/atom = 85.549
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.189271829051, Press = 0.304778595244892
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -17471.624     -17471.624     -17632.505     -17632.505      311.23591      311.23591      44112.333      44112.333     -262.36242     -262.36242    
     12000  -17479.89      -17479.89      -17639.079     -17639.079      307.96174      307.96174      44093.937      44093.937     -120.49883     -120.49883    
Loop time of 389.593 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.220 hours/ns, 2.567 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 388.59     | 388.59     | 388.59     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15698    | 0.15698    | 0.15698    |   0.0 |  0.04
Output  | 0.00019029 | 0.00019029 | 0.00019029 |   0.0 |  0.00
Modify  | 0.74614    | 0.74614    | 0.74614    |   0.0 |  0.19
Other   |            | 0.1001     |            |       |  0.03

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

Total # of neighbors = 342064
Ave neighs/atom = 85.516
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.095215444323, Press = 0.816555839115201
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -17479.89      -17479.89      -17639.079     -17639.079      307.96174      307.96174      44093.937      44093.937     -120.49883     -120.49883    
     13000  -17473.435     -17473.435     -17635.616     -17635.616      313.7502       313.7502       44102.958      44102.958     -126.59282     -126.59282    
Loop time of 387.856 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.738 hours/ns, 2.578 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 386.86     | 386.86     | 386.86     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1558     | 0.1558     | 0.1558     |   0.0 |  0.04
Output  | 0.00018942 | 0.00018942 | 0.00018942 |   0.0 |  0.00
Modify  | 0.7422     | 0.7422     | 0.7422     |   0.0 |  0.19
Other   |            | 0.09899    |            |       |  0.03

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

Total # of neighbors = 342318
Ave neighs/atom = 85.5795
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.937006052674, Press = 3.25297652497802
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -17473.435     -17473.435     -17635.616     -17635.616      313.7502       313.7502       44102.958      44102.958     -126.59282     -126.59282    
     14000  -17473.803     -17473.803     -17636.998     -17636.998      315.71156      315.71156      44075.44       44075.44       945.59757      945.59757    
Loop time of 391.959 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 108.877 hours/ns, 2.551 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 390.95     | 390.95     | 390.95     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15602    | 0.15602    | 0.15602    |   0.0 |  0.04
Output  | 0.00019305 | 0.00019305 | 0.00019305 |   0.0 |  0.00
Modify  | 0.75693    | 0.75693    | 0.75693    |   0.0 |  0.19
Other   |            | 0.1003     |            |       |  0.03

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

Total # of neighbors = 342050
Ave neighs/atom = 85.5125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.882248391906, Press = 3.92183180873196
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -17473.803     -17473.803     -17636.998     -17636.998      315.71156      315.71156      44075.44       44075.44       945.59757      945.59757    
     15000  -17477.487     -17477.487     -17639.385     -17639.385      313.2019       313.2019       44047.332      44047.332      1820.5568      1820.5568    
Loop time of 395.076 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.743 hours/ns, 2.531 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 394.05     | 394.05     | 394.05     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15871    | 0.15871    | 0.15871    |   0.0 |  0.04
Output  | 0.00018831 | 0.00018831 | 0.00018831 |   0.0 |  0.00
Modify  | 0.7646     | 0.7646     | 0.7646     |   0.0 |  0.19
Other   |            | 0.1018     |            |       |  0.03

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

Total # of neighbors = 342206
Ave neighs/atom = 85.5515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.789549736971, Press = 1.77496884480663
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -17477.487     -17477.487     -17639.385     -17639.385      313.2019       313.2019       44047.332      44047.332      1820.5568      1820.5568    
     16000  -17472.62      -17472.62      -17635.519     -17635.519      315.13869      315.13869      44054.634      44054.634      1999.4883      1999.4883    
Loop time of 389.765 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.268 hours/ns, 2.566 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 388.76     | 388.76     | 388.76     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15498    | 0.15498    | 0.15498    |   0.0 |  0.04
Output  | 0.00018923 | 0.00018923 | 0.00018923 |   0.0 |  0.00
Modify  | 0.74741    | 0.74741    | 0.74741    |   0.0 |  0.19
Other   |            | 0.1001     |            |       |  0.03

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

Total # of neighbors = 342284
Ave neighs/atom = 85.571
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.828018618535, Press = -0.881173793174385
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -17472.62      -17472.62      -17635.519     -17635.519      315.13869      315.13869      44054.634      44054.634      1999.4883      1999.4883    
     17000  -17472.256     -17472.256     -17636.902     -17636.902      318.51806      318.51806      44062.904      44062.904      1472.3597      1472.3597    
Loop time of 384.853 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.904 hours/ns, 2.598 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 383.87     | 383.87     | 383.87     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15272    | 0.15272    | 0.15272    |   0.0 |  0.04
Output  | 0.00018933 | 0.00018933 | 0.00018933 |   0.0 |  0.00
Modify  | 0.73307    | 0.73307    | 0.73307    |   0.0 |  0.19
Other   |            | 0.1001     |            |       |  0.03

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

Total # of neighbors = 342140
Ave neighs/atom = 85.535
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.890193711636, Press = -2.62481372378617
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -17472.256     -17472.256     -17636.902     -17636.902      318.51806      318.51806      44062.904      44062.904      1472.3597      1472.3597    
     18000  -17477.286     -17477.286     -17637.55      -17637.55       310.0414       310.0414       44070.251      44070.251      1090.8228      1090.8228    
Loop time of 391.237 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.677 hours/ns, 2.556 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 390.23     | 390.23     | 390.23     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15442    | 0.15442    | 0.15442    |   0.0 |  0.04
Output  | 0.00018974 | 0.00018974 | 0.00018974 |   0.0 |  0.00
Modify  | 0.75026    | 0.75026    | 0.75026    |   0.0 |  0.19
Other   |            | 0.1007     |            |       |  0.03

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

Total # of neighbors = 342120
Ave neighs/atom = 85.53
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.901372358346, Press = -4.19752275620153
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -17477.286     -17477.286     -17637.55      -17637.55       310.0414       310.0414       44070.251      44070.251      1090.8228      1090.8228    
     19000  -17473.224     -17473.224     -17636.287     -17636.287      315.45663      315.45663      44100.807      44100.807     -46.418382     -46.418382    
Loop time of 393.022 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.173 hours/ns, 2.544 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 392        | 392        | 392        |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15628    | 0.15628    | 0.15628    |   0.0 |  0.04
Output  | 0.00029497 | 0.00029497 | 0.00029497 |   0.0 |  0.00
Modify  | 0.7665     | 0.7665     | 0.7665     |   0.0 |  0.20
Other   |            | 0.1009     |            |       |  0.03

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

Total # of neighbors = 342158
Ave neighs/atom = 85.5395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.899652531053, Press = -5.34583083810595
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -17473.224     -17473.224     -17636.287     -17636.287      315.45663      315.45663      44100.807      44100.807     -46.418382     -46.418382    
     20000  -17468.72      -17468.72      -17635.882     -17635.882      323.38533      323.38533      44134.835      44134.835     -1358.9573     -1358.9573    
Loop time of 389.664 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.240 hours/ns, 2.566 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 388.66     | 388.66     | 388.66     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15619    | 0.15619    | 0.15619    |   0.0 |  0.04
Output  | 0.00019039 | 0.00019039 | 0.00019039 |   0.0 |  0.00
Modify  | 0.74511    | 0.74511    | 0.74511    |   0.0 |  0.19
Other   |            | 0.09907    |            |       |  0.03

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

Total # of neighbors = 342106
Ave neighs/atom = 85.5265
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.977988378432, Press = -5.97977643655825
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -17468.72      -17468.72      -17635.882     -17635.882      323.38533      323.38533      44134.835      44134.835     -1358.9573     -1358.9573    
     21000  -17476.731     -17476.731     -17634.486     -17634.486      305.18651      305.18651      44133.642      44133.642     -1430.1576     -1430.1576    
Loop time of 391.773 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.826 hours/ns, 2.552 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 390.76     | 390.76     | 390.76     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15571    | 0.15571    | 0.15571    |   0.0 |  0.04
Output  | 0.00018857 | 0.00018857 | 0.00018857 |   0.0 |  0.00
Modify  | 0.75287    | 0.75287    | 0.75287    |   0.0 |  0.19
Other   |            | 0.1003     |            |       |  0.03

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

Total # of neighbors = 341980
Ave neighs/atom = 85.495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.022164299763, Press = -3.46634987167576
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -17476.731     -17476.731     -17634.486     -17634.486      305.18651      305.18651      44133.642      44133.642     -1430.1576     -1430.1576    
     22000  -17471.951     -17471.951     -17635.15      -17635.15       315.71929      315.71929      44130.004      44130.004     -1257.7521     -1257.7521    
Loop time of 389.005 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.057 hours/ns, 2.571 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 388        | 388        | 388        |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15583    | 0.15583    | 0.15583    |   0.0 |  0.04
Output  | 0.00024181 | 0.00024181 | 0.00024181 |   0.0 |  0.00
Modify  | 0.75161    | 0.75161    | 0.75161    |   0.0 |  0.19
Other   |            | 0.1011     |            |       |  0.03

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

Total # of neighbors = 341984
Ave neighs/atom = 85.496
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.028499295835, Press = -1.637058927802
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -17471.951     -17471.951     -17635.15      -17635.15       315.71929      315.71929      44130.004      44130.004     -1257.7521     -1257.7521    
     23000  -17477.044     -17477.044     -17638.205     -17638.205      311.77716      311.77716      44116.07       44116.07      -911.79196     -911.79196    
Loop time of 385.879 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.188 hours/ns, 2.591 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 384.88     | 384.88     | 384.88     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15472    | 0.15472    | 0.15472    |   0.0 |  0.04
Output  | 0.00018727 | 0.00018727 | 0.00018727 |   0.0 |  0.00
Modify  | 0.73952    | 0.73952    | 0.73952    |   0.0 |  0.19
Other   |            | 0.09934    |            |       |  0.03

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

Total # of neighbors = 342036
Ave neighs/atom = 85.509
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.046835737468, Press = -1.37221569563774
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -17477.044     -17477.044     -17638.205     -17638.205      311.77716      311.77716      44116.07       44116.07      -911.79196     -911.79196    
     24000  -17466.338     -17466.338     -17632.945     -17632.945      322.31319      322.31319      44136.216      44136.216     -1143.0086     -1143.0086    
Loop time of 387.971 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.770 hours/ns, 2.578 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 386.97     | 386.97     | 386.97     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15485    | 0.15485    | 0.15485    |   0.0 |  0.04
Output  | 0.00018822 | 0.00018822 | 0.00018822 |   0.0 |  0.00
Modify  | 0.74714    | 0.74714    | 0.74714    |   0.0 |  0.19
Other   |            | 0.1002     |            |       |  0.03

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

Total # of neighbors = 342122
Ave neighs/atom = 85.5305
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.146342803304, Press = -1.08849739674782
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -17466.338     -17466.338     -17632.945     -17632.945      322.31319      322.31319      44136.216      44136.216     -1143.0086     -1143.0086    
     25000  -17475.702     -17475.702     -17633.85      -17633.85       305.94795      305.94795      44158.482      44158.482     -2337.9464     -2337.9464    
Loop time of 384.5 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.806 hours/ns, 2.601 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 383.5      | 383.5      | 383.5      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15458    | 0.15458    | 0.15458    |   0.0 |  0.04
Output  | 0.00018651 | 0.00018651 | 0.00018651 |   0.0 |  0.00
Modify  | 0.74058    | 0.74058    | 0.74058    |   0.0 |  0.19
Other   |            | 0.1004     |            |       |  0.03

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

Total # of neighbors = 341908
Ave neighs/atom = 85.477
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.177823095844, Press = 0.837132100622323
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -17475.702     -17475.702     -17633.85      -17633.85       305.94795      305.94795      44158.482      44158.482     -2337.9464     -2337.9464    
     26000  -17473.099     -17473.099     -17635.706     -17635.706      314.57411      314.57411      44139.812      44139.812     -1662.2219     -1662.2219    
Loop time of 381.663 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.017 hours/ns, 2.620 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 380.68     | 380.68     | 380.68     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15279    | 0.15279    | 0.15279    |   0.0 |  0.04
Output  | 0.00018824 | 0.00018824 | 0.00018824 |   0.0 |  0.00
Modify  | 0.72672    | 0.72672    | 0.72672    |   0.0 |  0.19
Other   |            | 0.0983     |            |       |  0.03

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

Total # of neighbors = 341966
Ave neighs/atom = 85.4915
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.248531852646, Press = 1.77726686920886
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -17473.099     -17473.099     -17635.706     -17635.706      314.57411      314.57411      44139.812      44139.812     -1662.2219     -1662.2219    
     27000  -17471.629     -17471.629     -17633.318     -17633.318      312.79774      312.79774      44115.361      44115.361     -407.5559      -407.5559     
Loop time of 386.363 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.323 hours/ns, 2.588 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 385.37     | 385.37     | 385.37     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15523    | 0.15523    | 0.15523    |   0.0 |  0.04
Output  | 0.00022251 | 0.00022251 | 0.00022251 |   0.0 |  0.00
Modify  | 0.73983    | 0.73983    | 0.73983    |   0.0 |  0.19
Other   |            | 0.09936    |            |       |  0.03

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

Total # of neighbors = 341974
Ave neighs/atom = 85.4935
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.230685221161, Press = 1.16605126793985
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -17471.629     -17471.629     -17633.318     -17633.318      312.79774      312.79774      44115.361      44115.361     -407.5559      -407.5559     
     28000  -17478.797     -17478.797     -17639.179     -17639.179      310.27004      310.27004      44086.02       44086.02       229.00288      229.00288    
Loop time of 386.909 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.475 hours/ns, 2.585 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 385.92     | 385.92     | 385.92     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15479    | 0.15479    | 0.15479    |   0.0 |  0.04
Output  | 0.00018784 | 0.00018784 | 0.00018784 |   0.0 |  0.00
Modify  | 0.73549    | 0.73549    | 0.73549    |   0.0 |  0.19
Other   |            | 0.09918    |            |       |  0.03

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

Total # of neighbors = 341982
Ave neighs/atom = 85.4955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.171592512851, Press = 0.716544920533563
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -17478.797     -17478.797     -17639.179     -17639.179      310.27004      310.27004      44086.02       44086.02       229.00288      229.00288    
     29000  -17473.313     -17473.313     -17634.115     -17634.115      311.08349      311.08349      44080.813      44080.813      923.4024       923.4024     
Loop time of 391.729 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.814 hours/ns, 2.553 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 390.72     | 390.72     | 390.72     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15655    | 0.15655    | 0.15655    |   0.0 |  0.04
Output  | 0.000243   | 0.000243   | 0.000243   |   0.0 |  0.00
Modify  | 0.75084    | 0.75084    | 0.75084    |   0.0 |  0.19
Other   |            | 0.09984    |            |       |  0.03

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

Total # of neighbors = 342144
Ave neighs/atom = 85.536
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.161293411784, Press = 0.365868875054127
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -17473.313     -17473.313     -17634.115     -17634.115      311.08349      311.08349      44080.813      44080.813      923.4024       923.4024     
     30000  -17471.509     -17471.509     -17633.607     -17633.607      313.58896      313.58896      44048.91       44048.91       2370.7746      2370.7746    
Loop time of 388.368 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 107.880 hours/ns, 2.575 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 387.37     | 387.37     | 387.37     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15513    | 0.15513    | 0.15513    |   0.0 |  0.04
Output  | 0.00018609 | 0.00018609 | 0.00018609 |   0.0 |  0.00
Modify  | 0.74575    | 0.74575    | 0.74575    |   0.0 |  0.19
Other   |            | 0.09927    |            |       |  0.03

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

Total # of neighbors = 342104
Ave neighs/atom = 85.526
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.116938555029, Press = 0.644574304432853
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -17471.509     -17471.509     -17633.607     -17633.607      313.58896      313.58896      44048.91       44048.91       2370.7746      2370.7746    
     31000  -17472.283     -17472.283     -17633.112     -17633.112      311.1351       311.1351       44014.513      44014.513      3735.5772      3735.5772    
Loop time of 395.138 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.760 hours/ns, 2.531 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 394.12     | 394.12     | 394.12     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15729    | 0.15729    | 0.15729    |   0.0 |  0.04
Output  | 0.00023368 | 0.00023368 | 0.00023368 |   0.0 |  0.00
Modify  | 0.75782    | 0.75782    | 0.75782    |   0.0 |  0.19
Other   |            | 0.1002     |            |       |  0.03

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

Total # of neighbors = 342174
Ave neighs/atom = 85.5435
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.055815668941, Press = -0.267859408786762
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -17472.283     -17472.283     -17633.112     -17633.112      311.1351       311.1351       44014.513      44014.513      3735.5772      3735.5772    
     32000  -17474.02      -17474.02      -17635.598     -17635.598      312.58279      312.58279      44052.332      44052.332      1983.7335      1983.7335    
Loop time of 385.141 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 106.984 hours/ns, 2.596 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 384.15     | 384.15     | 384.15     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1538     | 0.1538     | 0.1538     |   0.0 |  0.04
Output  | 0.00018915 | 0.00018915 | 0.00018915 |   0.0 |  0.00
Modify  | 0.73278    | 0.73278    | 0.73278    |   0.0 |  0.19
Other   |            | 0.09955    |            |       |  0.03

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

Total # of neighbors = 342244
Ave neighs/atom = 85.561
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.009083429068, Press = -0.986560634505612
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -17474.02      -17474.02      -17635.598     -17635.598      312.58279      312.58279      44052.332      44052.332      1983.7335      1983.7335    
     33000  -17478.593     -17478.593     -17639.929     -17639.929      312.11486      312.11486      44073.019      44073.019      728.43761      728.43761    
Loop time of 384.588 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.830 hours/ns, 2.600 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 383.6      | 383.6      | 383.6      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15454    | 0.15454    | 0.15454    |   0.0 |  0.04
Output  | 0.00018887 | 0.00018887 | 0.00018887 |   0.0 |  0.00
Modify  | 0.73803    | 0.73803    | 0.73803    |   0.0 |  0.19
Other   |            | 0.09861    |            |       |  0.03

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

Total # of neighbors = 342206
Ave neighs/atom = 85.5515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.015769832468, Press = -1.37365053339496
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -17478.593     -17478.593     -17639.929     -17639.929      312.11486      312.11486      44073.019      44073.019      728.43761      728.43761    
     34000  -17471.424     -17471.424     -17633.305     -17633.305      313.16925      313.16925      44093.469      44093.469      395.5353       395.5353     
Loop time of 388.195 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.832 hours/ns, 2.576 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 387.2      | 387.2      | 387.2      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15466    | 0.15466    | 0.15466    |   0.0 |  0.04
Output  | 0.00018983 | 0.00018983 | 0.00018983 |   0.0 |  0.00
Modify  | 0.74133    | 0.74133    | 0.74133    |   0.0 |  0.19
Other   |            | 0.09972    |            |       |  0.03

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

Total # of neighbors = 342236
Ave neighs/atom = 85.559
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.968918732883, Press = -1.41365170348224
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -17471.424     -17471.424     -17633.305     -17633.305      313.16925      313.16925      44093.469      44093.469      395.5353       395.5353     
     35000  -17477.2       -17477.2       -17637.802     -17637.802      310.69471      310.69471      44097.038      44097.038     -141.42668     -141.42668    
Loop time of 390.902 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.584 hours/ns, 2.558 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 389.88     | 389.88     | 389.88     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15692    | 0.15692    | 0.15692    |   0.0 |  0.04
Output  | 0.00023049 | 0.00023049 | 0.00023049 |   0.0 |  0.00
Modify  | 0.76157    | 0.76157    | 0.76157    |   0.0 |  0.19
Other   |            | 0.1013     |            |       |  0.03

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

Total # of neighbors = 342036
Ave neighs/atom = 85.509
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.96209918818, Press = -2.09960388882219
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -17477.2       -17477.2       -17637.802     -17637.802      310.69471      310.69471      44097.038      44097.038     -141.42668     -141.42668    
     36000  -17472.6       -17472.6       -17632.262     -17632.262      308.87723      308.87723      44140.065      44140.065     -1528.6412     -1528.6412    
Loop time of 394.811 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.670 hours/ns, 2.533 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 393.79     | 393.79     | 393.79     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15582    | 0.15582    | 0.15582    |   0.0 |  0.04
Output  | 0.00018824 | 0.00018824 | 0.00018824 |   0.0 |  0.00
Modify  | 0.76028    | 0.76028    | 0.76028    |   0.0 |  0.19
Other   |            | 0.1009     |            |       |  0.03

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

Total # of neighbors = 342146
Ave neighs/atom = 85.5365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.960481378901, Press = -3.62009991535459
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -17472.6       -17472.6       -17632.262     -17632.262      308.87723      308.87723      44140.065      44140.065     -1528.6412     -1528.6412    
     37000  -17477.846     -17477.846     -17639.135     -17639.135      312.02399      312.02399      44138.167      44138.167     -1970.3732     -1970.3732    
Loop time of 389.842 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.289 hours/ns, 2.565 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 388.84     | 388.84     | 388.84     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15428    | 0.15428    | 0.15428    |   0.0 |  0.04
Output  | 0.0001874  | 0.0001874  | 0.0001874  |   0.0 |  0.00
Modify  | 0.74349    | 0.74349    | 0.74349    |   0.0 |  0.19
Other   |            | 0.1004     |            |       |  0.03

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

Total # of neighbors = 341970
Ave neighs/atom = 85.4925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.003497071158, Press = -1.72611786424968
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -17477.846     -17477.846     -17639.135     -17639.135      312.02399      312.02399      44138.167      44138.167     -1970.3732     -1970.3732    
     38000  -17473.656     -17473.656     -17634.502     -17634.502      311.16839      311.16839      44137.386      44137.386     -1590.7805     -1590.7805    
Loop time of 387.866 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.741 hours/ns, 2.578 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 386.86     | 386.86     | 386.86     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15366    | 0.15366    | 0.15366    |   0.0 |  0.04
Output  | 0.0005862  | 0.0005862  | 0.0005862  |   0.0 |  0.00
Modify  | 0.747      | 0.747      | 0.747      |   0.0 |  0.19
Other   |            | 0.1006     |            |       |  0.03

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

Total # of neighbors = 342042
Ave neighs/atom = 85.5105
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.997863830698, Press = -0.941420303786513
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -17473.656     -17473.656     -17634.502     -17634.502      311.16839      311.16839      44137.386      44137.386     -1590.7805     -1590.7805    
     39000  -17475.302     -17475.302     -17633.911     -17633.911      306.83878      306.83878      44134.187      44134.187     -1399.5324     -1399.5324    
Loop time of 391.573 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.770 hours/ns, 2.554 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 390.56     | 390.56     | 390.56     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15529    | 0.15529    | 0.15529    |   0.0 |  0.04
Output  | 0.00018829 | 0.00018829 | 0.00018829 |   0.0 |  0.00
Modify  | 0.75729    | 0.75729    | 0.75729    |   0.0 |  0.19
Other   |            | 0.1005     |            |       |  0.03

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

Total # of neighbors = 341888
Ave neighs/atom = 85.472
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.938351296168, Press = -0.309946689176199
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -17475.302     -17475.302     -17633.911     -17633.911      306.83878      306.83878      44134.187      44134.187     -1399.5324     -1399.5324    
     40000  -17474.383     -17474.383     -17638.323     -17638.323      317.15194      317.15194      44134.264      44134.264     -1657.1389     -1657.1389    
Loop time of 386.916 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.477 hours/ns, 2.585 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 385.93     | 385.93     | 385.93     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15253    | 0.15253    | 0.15253    |   0.0 |  0.04
Output  | 0.00018872 | 0.00018872 | 0.00018872 |   0.0 |  0.00
Modify  | 0.73763    | 0.73763    | 0.73763    |   0.0 |  0.19
Other   |            | 0.09992    |            |       |  0.03

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

Total # of neighbors = 342014
Ave neighs/atom = 85.5035
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.947054311582, Press = -0.0899241419113457
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -17474.383     -17474.383     -17638.323     -17638.323      317.15194      317.15194      44134.264      44134.264     -1657.1389     -1657.1389    
     41000  -17477.589     -17477.589     -17638.07      -17638.07       310.46204      310.46204      44135.606      44135.606     -1721.6999     -1721.6999    
Loop time of 382.858 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.350 hours/ns, 2.612 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 381.88     | 381.88     | 381.88     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15252    | 0.15252    | 0.15252    |   0.0 |  0.04
Output  | 0.00018813 | 0.00018813 | 0.00018813 |   0.0 |  0.00
Modify  | 0.73032    | 0.73032    | 0.73032    |   0.0 |  0.19
Other   |            | 0.09854    |            |       |  0.03

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

Total # of neighbors = 342152
Ave neighs/atom = 85.538
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.890555244694, Press = 0.317542184830861
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -17477.589     -17477.589     -17638.07      -17638.07       310.46204      310.46204      44135.606      44135.606     -1721.6999     -1721.6999    
     42000  -17475.869     -17475.869     -17636.577     -17636.577      310.90161      310.90161      44144.131      44144.131     -2051.1687     -2051.1687    
Loop time of 384.94 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 106.928 hours/ns, 2.598 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 383.95     | 383.95     | 383.95     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15408    | 0.15408    | 0.15408    |   0.0 |  0.04
Output  | 0.00028131 | 0.00028131 | 0.00028131 |   0.0 |  0.00
Modify  | 0.73285    | 0.73285    | 0.73285    |   0.0 |  0.19
Other   |            | 0.09837    |            |       |  0.03

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

Total # of neighbors = 342082
Ave neighs/atom = 85.5205
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.899051351854, Press = 1.29435869781348
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -17475.869     -17475.869     -17636.577     -17636.577      310.90161      310.90161      44144.131      44144.131     -2051.1687     -2051.1687    
     43000  -17472.887     -17472.887     -17636.635     -17636.635      316.78231      316.78231      44115.699      44115.699     -748.94583     -748.94583    
Loop time of 387.033 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.509 hours/ns, 2.584 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 386.04     | 386.04     | 386.04     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1541     | 0.1541     | 0.1541     |   0.0 |  0.04
Output  | 0.00024969 | 0.00024969 | 0.00024969 |   0.0 |  0.00
Modify  | 0.74408    | 0.74408    | 0.74408    |   0.0 |  0.19
Other   |            | 0.0996     |            |       |  0.03

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

Total # of neighbors = 341980
Ave neighs/atom = 85.495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.880591178906, Press = 1.53264355902727
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -17472.887     -17472.887     -17636.635     -17636.635      316.78231      316.78231      44115.699      44115.699     -748.94583     -748.94583    
     44000  -17477.803     -17477.803     -17640.667     -17640.667      315.07041      315.07041      44093.469      44093.469     -173.63469     -173.63469    
Loop time of 384.535 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.815 hours/ns, 2.601 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 383.54     | 383.54     | 383.54     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15424    | 0.15424    | 0.15424    |   0.0 |  0.04
Output  | 0.0002602  | 0.0002602  | 0.0002602  |   0.0 |  0.00
Modify  | 0.73636    | 0.73636    | 0.73636    |   0.0 |  0.19
Other   |            | 0.1005     |            |       |  0.03

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

Total # of neighbors = 341970
Ave neighs/atom = 85.4925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.889759214511, Press = 0.524069723942334
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -17477.803     -17477.803     -17640.667     -17640.667      315.07041      315.07041      44093.469      44093.469     -173.63469     -173.63469    
     45000  -17473.95      -17473.95      -17635.563     -17635.563      312.65123      312.65123      44091.213      44091.213      301.70786      301.70786    
Loop time of 385.311 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.031 hours/ns, 2.595 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 384.32     | 384.32     | 384.32     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15182    | 0.15182    | 0.15182    |   0.0 |  0.04
Output  | 0.00024222 | 0.00024222 | 0.00024222 |   0.0 |  0.00
Modify  | 0.7408     | 0.7408     | 0.7408     |   0.0 |  0.19
Other   |            | 0.09992    |            |       |  0.03

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

Total # of neighbors = 342202
Ave neighs/atom = 85.5505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.900773688675, Press = 0.424354045513035
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -17473.95      -17473.95      -17635.563     -17635.563      312.65123      312.65123      44091.213      44091.213      301.70786      301.70786    
     46000  -17471.77      -17471.77      -17635.59      -17635.59       316.91985      316.91985      44080.261      44080.261      830.33954      830.33954    
Loop time of 382.585 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.274 hours/ns, 2.614 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 381.61     | 381.61     | 381.61     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14866    | 0.14866    | 0.14866    |   0.0 |  0.04
Output  | 0.00018863 | 0.00018863 | 0.00018863 |   0.0 |  0.00
Modify  | 0.72946    | 0.72946    | 0.72946    |   0.0 |  0.19
Other   |            | 0.09872    |            |       |  0.03

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

Total # of neighbors = 342086
Ave neighs/atom = 85.5215
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.903747751546, Press = 0.321883749135379
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -17471.77      -17471.77      -17635.59      -17635.59       316.91985      316.91985      44080.261      44080.261      830.33954      830.33954    
     47000  -17481.15      -17481.15      -17638.978     -17638.978      305.32788      305.32788      44009.77       44009.77       3358.1759      3358.1759    
Loop time of 378.621 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.173 hours/ns, 2.641 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 377.65     | 377.65     | 377.65     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14769    | 0.14769    | 0.14769    |   0.0 |  0.04
Output  | 0.00018763 | 0.00018763 | 0.00018763 |   0.0 |  0.00
Modify  | 0.72081    | 0.72081    | 0.72081    |   0.0 |  0.19
Other   |            | 0.09785    |            |       |  0.03

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

Total # of neighbors = 342118
Ave neighs/atom = 85.5295
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.874936595819, Press = 1.14308755741549
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -17481.15      -17481.15      -17638.978     -17638.978      305.32788      305.32788      44009.77       44009.77       3358.1759      3358.1759    
     48000  -17471.266     -17471.266     -17634.055     -17634.055      314.92539      314.92539      44013.731      44013.731      3797.8172      3797.8172    
Loop time of 384.745 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.874 hours/ns, 2.599 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 383.75     | 383.75     | 383.75     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1491     | 0.1491     | 0.1491     |   0.0 |  0.04
Output  | 0.0002352  | 0.0002352  | 0.0002352  |   0.0 |  0.00
Modify  | 0.74104    | 0.74104    | 0.74104    |   0.0 |  0.19
Other   |            | 0.09955    |            |       |  0.03

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

Total # of neighbors = 342384
Ave neighs/atom = 85.596
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.861408417825, Press = 0.333018778739653
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -17471.266     -17471.266     -17634.055     -17634.055      314.92539      314.92539      44013.731      44013.731      3797.8172      3797.8172    
     49000  -17479.345     -17479.345     -17639.657     -17639.657      310.13565      310.13565      44038.824      44038.824      2223.146       2223.146     
Loop time of 382.207 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.169 hours/ns, 2.616 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 381.23     | 381.23     | 381.23     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14769    | 0.14769    | 0.14769    |   0.0 |  0.04
Output  | 0.00018783 | 0.00018783 | 0.00018783 |   0.0 |  0.00
Modify  | 0.73201    | 0.73201    | 0.73201    |   0.0 |  0.19
Other   |            | 0.09801    |            |       |  0.03

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

Total # of neighbors = 342322
Ave neighs/atom = 85.5805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.832323806691, Press = -0.275059225412987
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -17479.345     -17479.345     -17639.657     -17639.657      310.13565      310.13565      44038.824      44038.824      2223.146       2223.146     
     50000  -17471.509     -17471.509     -17635.551     -17635.551      317.34974      317.34974      44076.061      44076.061      987.19417      987.19417    
Loop time of 383.207 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.446 hours/ns, 2.610 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 382.23     | 382.23     | 382.23     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14915    | 0.14915    | 0.14915    |   0.0 |  0.04
Output  | 0.00023682 | 0.00023682 | 0.00023682 |   0.0 |  0.00
Modify  | 0.73105    | 0.73105    | 0.73105    |   0.0 |  0.19
Other   |            | 0.09902    |            |       |  0.03

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

Total # of neighbors = 342408
Ave neighs/atom = 85.602
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.814262755902, Press = -0.452164237312651
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -17471.509     -17471.509     -17635.551     -17635.551      317.34974      317.34974      44076.061      44076.061      987.19417      987.19417    
     51000  -17475.159     -17475.159     -17639.844     -17639.844      318.59522      318.59522      44080.5        44080.5        490.0258       490.0258     
Loop time of 385.5 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.083 hours/ns, 2.594 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 384.52     | 384.52     | 384.52     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15015    | 0.15015    | 0.15015    |   0.0 |  0.04
Output  | 0.00018708 | 0.00018708 | 0.00018708 |   0.0 |  0.00
Modify  | 0.73434    | 0.73434    | 0.73434    |   0.0 |  0.19
Other   |            | 0.099      |            |       |  0.03

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

Total # of neighbors = 342192
Ave neighs/atom = 85.548
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.853783648192, Press = -0.683629974976695
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -17475.159     -17475.159     -17639.844     -17639.844      318.59522      318.59522      44080.5        44080.5        490.0258       490.0258     
     52000  -17472.39      -17472.39      -17636.321     -17636.321      317.13606      317.13606      44102.122      44102.122     -116.59745     -116.59745    
Loop time of 379.733 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.481 hours/ns, 2.633 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 378.77     | 378.77     | 378.77     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14665    | 0.14665    | 0.14665    |   0.0 |  0.04
Output  | 0.00018939 | 0.00018939 | 0.00018939 |   0.0 |  0.00
Modify  | 0.71602    | 0.71602    | 0.71602    |   0.0 |  0.19
Other   |            | 0.09725    |            |       |  0.03

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

Total # of neighbors = 342262
Ave neighs/atom = 85.5655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.864632903197, Press = -0.892184767373252
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -17472.39      -17472.39      -17636.321     -17636.321      317.13606      317.13606      44102.122      44102.122     -116.59745     -116.59745    
     53000  -17474.554     -17474.554     -17633.645     -17633.645      307.7731       307.7731       44106.205      44106.205     -96.74231      -96.74231     
Loop time of 384.563 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.823 hours/ns, 2.600 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 383.58     | 383.58     | 383.58     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1485     | 0.1485     | 0.1485     |   0.0 |  0.04
Output  | 0.00018864 | 0.00018864 | 0.00018864 |   0.0 |  0.00
Modify  | 0.73602    | 0.73602    | 0.73602    |   0.0 |  0.19
Other   |            | 0.09901    |            |       |  0.03

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

Total # of neighbors = 342068
Ave neighs/atom = 85.517
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.838630392781, Press = -1.17425128182635
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -17474.554     -17474.554     -17633.645     -17633.645      307.7731       307.7731       44106.205      44106.205     -96.74231      -96.74231     
     54000  -17473.286     -17473.286     -17634.92      -17634.92       312.69066      312.69066      44149.288      44149.288     -2036.7778     -2036.7778    
Loop time of 384.99 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 106.942 hours/ns, 2.597 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 384.01     | 384.01     | 384.01     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14918    | 0.14918    | 0.14918    |   0.0 |  0.04
Output  | 0.0001897  | 0.0001897  | 0.0001897  |   0.0 |  0.00
Modify  | 0.73719    | 0.73719    | 0.73719    |   0.0 |  0.19
Other   |            | 0.09855    |            |       |  0.03

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

Total # of neighbors = 342086
Ave neighs/atom = 85.5215
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.864356071502, Press = -1.82280453492325
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -17473.286     -17473.286     -17634.92      -17634.92       312.69066      312.69066      44149.288      44149.288     -2036.7778     -2036.7778    
     55000  -17467.224     -17467.224     -17631.122     -17631.122      317.07199      317.07199      44156.318      44156.318     -1918.4171     -1918.4171    
Loop time of 383.696 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.582 hours/ns, 2.606 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 382.72     | 382.72     | 382.72     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14842    | 0.14842    | 0.14842    |   0.0 |  0.04
Output  | 0.00023693 | 0.00023693 | 0.00023693 |   0.0 |  0.00
Modify  | 0.72633    | 0.72633    | 0.72633    |   0.0 |  0.19
Other   |            | 0.09806    |            |       |  0.03

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

Total # of neighbors = 342050
Ave neighs/atom = 85.5125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.874539244918, Press = -0.76032927853907
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -17467.224     -17467.224     -17631.122     -17631.122      317.07199      317.07199      44156.318      44156.318     -1918.4171     -1918.4171    
     56000  -17475.65      -17475.65      -17635.578     -17635.578      309.39077      309.39077      44123.896      44123.896     -1166.2847     -1166.2847    
Loop time of 379.46 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.406 hours/ns, 2.635 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 378.5      | 378.5      | 378.5      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14663    | 0.14663    | 0.14663    |   0.0 |  0.04
Output  | 0.00018897 | 0.00018897 | 0.00018897 |   0.0 |  0.00
Modify  | 0.71325    | 0.71325    | 0.71325    |   0.0 |  0.19
Other   |            | 0.09799    |            |       |  0.03

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

Total # of neighbors = 341948
Ave neighs/atom = 85.487
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.91003967729, Press = -0.276417941849776
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -17475.65      -17475.65      -17635.578     -17635.578      309.39077      309.39077      44123.896      44123.896     -1166.2847     -1166.2847    
     57000  -17470.868     -17470.868     -17633.586     -17633.586      314.78792      314.78792      44125.232      44125.232     -903.0609      -903.0609     
Loop time of 385.005 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 106.946 hours/ns, 2.597 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 384.02     | 384.02     | 384.02     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14938    | 0.14938    | 0.14938    |   0.0 |  0.04
Output  | 0.00018827 | 0.00018827 | 0.00018827 |   0.0 |  0.00
Modify  | 0.73684    | 0.73684    | 0.73684    |   0.0 |  0.19
Other   |            | 0.09903    |            |       |  0.03

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

Total # of neighbors = 342028
Ave neighs/atom = 85.507
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.942749308995, Press = -0.0123407283484213
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -17470.868     -17470.868     -17633.586     -17633.586      314.78792      314.78792      44125.232      44125.232     -903.0609      -903.0609     
     58000  -17478.688     -17478.688     -17639.181     -17639.181      310.48333      310.48333      44114.942      44114.942     -992.71679     -992.71679    
Loop time of 386.48 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.355 hours/ns, 2.587 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 385.49     | 385.49     | 385.49     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14952    | 0.14952    | 0.14952    |   0.0 |  0.04
Output  | 0.00018856 | 0.00018856 | 0.00018856 |   0.0 |  0.00
Modify  | 0.74006    | 0.74006    | 0.74006    |   0.0 |  0.19
Other   |            | 0.09966    |            |       |  0.03

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

Total # of neighbors = 342012
Ave neighs/atom = 85.503
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.923417027196, Press = 0.12475977153743
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -17478.688     -17478.688     -17639.181     -17639.181      310.48333      310.48333      44114.942      44114.942     -992.71679     -992.71679    
     59000  -17472.38      -17472.38      -17632.501     -17632.501      309.76498      309.76498      44120.535      44120.535     -595.42284     -595.42284    
Loop time of 386.997 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.499 hours/ns, 2.584 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 386.01     | 386.01     | 386.01     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14996    | 0.14996    | 0.14996    |   0.0 |  0.04
Output  | 0.00018691 | 0.00018691 | 0.00018691 |   0.0 |  0.00
Modify  | 0.74137    | 0.74137    | 0.74137    |   0.0 |  0.19
Other   |            | 0.09912    |            |       |  0.03

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

Total # of neighbors = 342076
Ave neighs/atom = 85.519
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.87954539757, Press = 0.49174396199601
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -17472.38      -17472.38      -17632.501     -17632.501      309.76498      309.76498      44120.535      44120.535     -595.42284     -595.42284    
     60000  -17473.3       -17473.3       -17633.183     -17633.183      309.30404      309.30404      44106.964      44106.964     -166.35117     -166.35117    
Loop time of 383.368 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.491 hours/ns, 2.608 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 382.38     | 382.38     | 382.38     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14951    | 0.14951    | 0.14951    |   0.0 |  0.04
Output  | 0.00019032 | 0.00019032 | 0.00019032 |   0.0 |  0.00
Modify  | 0.73391    | 0.73391    | 0.73391    |   0.0 |  0.19
Other   |            | 0.09983    |            |       |  0.03

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

Total # of neighbors = 341996
Ave neighs/atom = 85.499
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.880895211501, Press = 0.970716794216234
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -17473.3       -17473.3       -17633.183     -17633.183      309.30404      309.30404      44106.964      44106.964     -166.35117     -166.35117    
     61000  -17474.038     -17474.038     -17635.643     -17635.643      312.63686      312.63686      44086.35       44086.35       592.06835      592.06835    
Loop time of 384.067 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.685 hours/ns, 2.604 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 383.09     | 383.09     | 383.09     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15017    | 0.15017    | 0.15017    |   0.0 |  0.04
Output  | 0.00023421 | 0.00023421 | 0.00023421 |   0.0 |  0.00
Modify  | 0.73246    | 0.73246    | 0.73246    |   0.0 |  0.19
Other   |            | 0.09861    |            |       |  0.03

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

Total # of neighbors = 342028
Ave neighs/atom = 85.507
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.889978740486, Press = 0.902510520107077
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -17474.038     -17474.038     -17635.643     -17635.643      312.63686      312.63686      44086.35       44086.35       592.06835      592.06835    
     62000  -17472.922     -17472.922     -17633.129     -17633.129      309.9309       309.9309       44068.819      44068.819      1470.6902      1470.6902    
Loop time of 388.023 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.784 hours/ns, 2.577 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 387.03     | 387.03     | 387.03     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15003    | 0.15003    | 0.15003    |   0.0 |  0.04
Output  | 0.00018795 | 0.00018795 | 0.00018795 |   0.0 |  0.00
Modify  | 0.74363    | 0.74363    | 0.74363    |   0.0 |  0.19
Other   |            | 0.09947    |            |       |  0.03

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

Total # of neighbors = 342078
Ave neighs/atom = 85.5195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.927833836278, Press = 0.627878990845323
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -17472.922     -17472.922     -17633.129     -17633.129      309.9309       309.9309       44068.819      44068.819      1470.6902      1470.6902    
     63000  -17472.852     -17472.852     -17634.846     -17634.846      313.38806      313.38806      44069.615      44069.615      1364.2907      1364.2907    
Loop time of 385.347 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.041 hours/ns, 2.595 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 384.36     | 384.36     | 384.36     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1499     | 0.1499     | 0.1499     |   0.0 |  0.04
Output  | 0.00023945 | 0.00023945 | 0.00023945 |   0.0 |  0.00
Modify  | 0.73853    | 0.73853    | 0.73853    |   0.0 |  0.19
Other   |            | 0.09947    |            |       |  0.03

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

Total # of neighbors = 342162
Ave neighs/atom = 85.5405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.946155304258, Press = 0.325504889326958
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.61 | 4.61 | 4.61 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -17472.852     -17472.852     -17634.846     -17634.846      313.38806      313.38806      44069.615      44069.615      1364.2907      1364.2907    
     64000  -17477.477     -17477.477     -17636.231     -17636.231      307.12143      307.12143      44071.566      44071.566      1050.967       1050.967     
Loop time of 383.055 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.404 hours/ns, 2.611 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 382.08     | 382.08     | 382.08     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14764    | 0.14764    | 0.14764    |   0.0 |  0.04
Output  | 0.0002319  | 0.0002319  | 0.0002319  |   0.0 |  0.00
Modify  | 0.72838    | 0.72838    | 0.72838    |   0.0 |  0.19
Other   |            | 0.09817    |            |       |  0.03

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

Total # of neighbors = 342162
Ave neighs/atom = 85.5405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
44098.6172950229

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0