# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 4.049999177455902*${_u_distance}
variable latticeconst_converted equal 4.049999177455902*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.0499991774559
Lattice spacing in x,y,z = 4.0499992 4.0499992 4.0499992
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (40.499992 40.499992 40.499992)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (40.499992 40.499992 40.499992)
  create_atoms CPU = 0.000 seconds

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

kim_interactions Al

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

kim interactions Al
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_JelinekGrohHorstemeyer_2012_AlSiMgCuFe__MO_262519520678_002
pair_coeff * * Al
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 26.981538

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66430.0845246695 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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_262519520678_002#item-citation

CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE-CITE

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13260.468     -13260.468     -13412         -13412          293.15         293.15         66430.085      66430.085      2436.4673      2436.4673    
      1000  -13098.434     -13098.434     -13262.1       -13262.1        316.62343      316.62343      67181.811      67181.811      933.16584      933.16584    
Loop time of 171.407 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.504 ns/day, 47.613 hours/ns, 5.834 timesteps/s
39.4% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 170.83     | 170.83     | 170.83     |   0.0 | 99.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043155   | 0.043155   | 0.043155   |   0.0 |  0.03
Output  | 0.00028006 | 0.00028006 | 0.00028006 |   0.0 |  0.00
Modify  | 0.51392    | 0.51392    | 0.51392    |   0.0 |  0.30
Other   |            | 0.01674    |            |       |  0.01

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

Total # of neighbors = 312000
Ave neighs/atom = 78
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13098.434     -13098.434     -13262.1       -13262.1        316.62343      316.62343      67181.811      67181.811      933.16584      933.16584    
      2000  -13110.852     -13110.852     -13258.497     -13258.497      285.62833      285.62833      67201.167      67201.167      593.33991      593.33991    
Loop time of 104.477 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.827 ns/day, 29.022 hours/ns, 9.571 timesteps/s
70.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.24     | 104.24     | 104.24     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.026093   | 0.026093   | 0.026093   |   0.0 |  0.02
Output  | 0.000491   | 0.000491   | 0.000491   |   0.0 |  0.00
Modify  | 0.19165    | 0.19165    | 0.19165    |   0.0 |  0.18
Other   |            | 0.01675    |            |       |  0.02

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

Total # of neighbors = 323812
Ave neighs/atom = 80.953
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13110.852     -13110.852     -13258.497     -13258.497      285.62833      285.62833      67201.167      67201.167      593.33991      593.33991    
      3000  -13103.753     -13103.753     -13256.215     -13256.215      294.94915      294.94915      67249.866      67249.866      186.71993      186.71993    
Loop time of 84.8344 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.018 ns/day, 23.565 hours/ns, 11.788 timesteps/s
86.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    | 84.645     | 84.645     | 84.645     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025108   | 0.025108   | 0.025108   |   0.0 |  0.03
Output  | 0.00010417 | 0.00010417 | 0.00010417 |   0.0 |  0.00
Modify  | 0.13984    | 0.13984    | 0.13984    |   0.0 |  0.16
Other   |            | 0.02479    |            |       |  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:       323496 ave      323496 max      323496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323496
Ave neighs/atom = 80.874
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13103.753     -13103.753     -13256.215     -13256.215      294.94915      294.94915      67249.866      67249.866      186.71993      186.71993    
      4000  -13107.396     -13107.396     -13262.12      -13262.12       299.32246      299.32246      67267.852      67267.852     -228.95142     -228.95142    
Loop time of 90.3121 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.957 ns/day, 25.087 hours/ns, 11.073 timesteps/s
85.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    | 90.117     | 90.117     | 90.117     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02838    | 0.02838    | 0.02838    |   0.0 |  0.03
Output  | 0.00030141 | 0.00030141 | 0.00030141 |   0.0 |  0.00
Modify  | 0.1428     | 0.1428     | 0.1428     |   0.0 |  0.16
Other   |            | 0.02376    |            |       |  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:       323356 ave      323356 max      323356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323356
Ave neighs/atom = 80.839
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13107.396     -13107.396     -13262.12      -13262.12       299.32246      299.32246      67267.852      67267.852     -228.95142     -228.95142    
      5000  -13106.399     -13106.399     -13256.932     -13256.932      291.21651      291.21651      67273.686      67273.686     -109.0348      -109.0348     
Loop time of 82.5906 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.046 ns/day, 22.942 hours/ns, 12.108 timesteps/s
92.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 82.393     | 82.393     | 82.393     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.028599   | 0.028599   | 0.028599   |   0.0 |  0.03
Output  | 7.0993e-05 | 7.0993e-05 | 7.0993e-05 |   0.0 |  0.00
Modify  | 0.1484     | 0.1484     | 0.1484     |   0.0 |  0.18
Other   |            | 0.02068    |            |       |  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:       323378 ave      323378 max      323378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323378
Ave neighs/atom = 80.8445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 294.619870589274, Press = -421.854168465728
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13106.399     -13106.399     -13256.932     -13256.932      291.21651      291.21651      67273.686      67273.686     -109.0348      -109.0348     
      6000  -13104.722     -13104.722     -13256.353     -13256.353      293.34081      293.34081      67337.525      67337.525     -831.46677     -831.46677    
Loop time of 82.2738 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.050 ns/day, 22.854 hours/ns, 12.155 timesteps/s
93.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    | 82.054     | 82.054     | 82.054     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.036698   | 0.036698   | 0.036698   |   0.0 |  0.04
Output  | 7.2967e-05 | 7.2967e-05 | 7.2967e-05 |   0.0 |  0.00
Modify  | 0.16638    | 0.16638    | 0.16638    |   0.0 |  0.20
Other   |            | 0.0169     |            |       |  0.02

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

Total # of neighbors = 323264
Ave neighs/atom = 80.816
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.533478515171, Press = -52.7105194658499
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13104.722     -13104.722     -13256.353     -13256.353      293.34081      293.34081      67337.525      67337.525     -831.46677     -831.46677    
      7000  -13109.801     -13109.801     -13258.443     -13258.443      287.55926      287.55926      67351.391      67351.391     -1165.9339     -1165.9339    
Loop time of 78.1099 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.106 ns/day, 21.697 hours/ns, 12.802 timesteps/s
98.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 77.927     | 77.927     | 77.927     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025702   | 0.025702   | 0.025702   |   0.0 |  0.03
Output  | 7.8938e-05 | 7.8938e-05 | 7.8938e-05 |   0.0 |  0.00
Modify  | 0.14198    | 0.14198    | 0.14198    |   0.0 |  0.18
Other   |            | 0.01502    |            |       |  0.02

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

Total # of neighbors = 323206
Ave neighs/atom = 80.8015
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.053330512429, Press = -19.6975447779069
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13109.801     -13109.801     -13258.443     -13258.443      287.55926      287.55926      67351.391      67351.391     -1165.9339     -1165.9339    
      8000  -13105.2       -13105.2       -13258.384     -13258.384      296.34451      296.34451      67331.191      67331.191     -804.82191     -804.82191    
Loop time of 77.8404 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.110 ns/day, 21.622 hours/ns, 12.847 timesteps/s
99.2% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 77.659     | 77.659     | 77.659     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025526   | 0.025526   | 0.025526   |   0.0 |  0.03
Output  | 8.0521e-05 | 8.0521e-05 | 8.0521e-05 |   0.0 |  0.00
Modify  | 0.14124    | 0.14124    | 0.14124    |   0.0 |  0.18
Other   |            | 0.015      |            |       |  0.02

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

Total # of neighbors = 323094
Ave neighs/atom = 80.7735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.997794612813, Press = -7.25391335051692
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13105.2       -13105.2       -13258.384     -13258.384      296.34451      296.34451      67331.191      67331.191     -804.82191     -804.82191    
      9000  -13107.48      -13107.48      -13258.64      -13258.64       292.4294       292.4294       67280.918      67280.918     -300.96625     -300.96625    
Loop time of 77.9247 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.109 ns/day, 21.646 hours/ns, 12.833 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 77.742     | 77.742     | 77.742     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025538   | 0.025538   | 0.025538   |   0.0 |  0.03
Output  | 7.5111e-05 | 7.5111e-05 | 7.5111e-05 |   0.0 |  0.00
Modify  | 0.14235    | 0.14235    | 0.14235    |   0.0 |  0.18
Other   |            | 0.01502    |            |       |  0.02

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

Total # of neighbors = 322950
Ave neighs/atom = 80.7375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.597600697335, Press = -2.83611310294928
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13107.48      -13107.48      -13258.64      -13258.64       292.4294       292.4294       67280.918      67280.918     -300.96625     -300.96625    
     10000  -13108.316     -13108.316     -13261.075     -13261.075      295.52334      295.52334      67271.786      67271.786     -282.18375     -282.18375    
Loop time of 79.2766 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.090 ns/day, 22.021 hours/ns, 12.614 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 79.092     | 79.092     | 79.092     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.026004   | 0.026004   | 0.026004   |   0.0 |  0.03
Output  | 8.0481e-05 | 8.0481e-05 | 8.0481e-05 |   0.0 |  0.00
Modify  | 0.14313    | 0.14313    | 0.14313    |   0.0 |  0.18
Other   |            | 0.01505    |            |       |  0.02

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

Total # of neighbors = 323304
Ave neighs/atom = 80.826
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.577747568443, Press = -3.30941363958966
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13108.316     -13108.316     -13261.075     -13261.075      295.52334      295.52334      67271.786      67271.786     -282.18375     -282.18375    
     11000  -13105.392     -13105.392     -13259.347     -13259.347      297.83527      297.83527      67326.346      67326.346     -821.55652     -821.55652    
Loop time of 78.9159 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.095 ns/day, 21.921 hours/ns, 12.672 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 78.731     | 78.731     | 78.731     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.026034   | 0.026034   | 0.026034   |   0.0 |  0.03
Output  | 7.7255e-05 | 7.7255e-05 | 7.7255e-05 |   0.0 |  0.00
Modify  | 0.14348    | 0.14348    | 0.14348    |   0.0 |  0.18
Other   |            | 0.01515    |            |       |  0.02

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

Total # of neighbors = 323332
Ave neighs/atom = 80.833
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.350793173704, Press = -1.51157118669216
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13105.392     -13105.392     -13259.347     -13259.347      297.83527      297.83527      67326.346      67326.346     -821.55652     -821.55652    
     12000  -13110.659     -13110.659     -13261.139     -13261.139      291.11237      291.11237      67330.259      67330.259     -1002.1525     -1002.1525    
Loop time of 78.296 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.104 ns/day, 21.749 hours/ns, 12.772 timesteps/s
99.3% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 78.11      | 78.11      | 78.11      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.026094   | 0.026094   | 0.026094   |   0.0 |  0.03
Output  | 7.5632e-05 | 7.5632e-05 | 7.5632e-05 |   0.0 |  0.00
Modify  | 0.14428    | 0.14428    | 0.14428    |   0.0 |  0.18
Other   |            | 0.01545    |            |       |  0.02

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

Total # of neighbors = 322936
Ave neighs/atom = 80.734
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.318046770134, Press = 2.37304898449002
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13110.659     -13110.659     -13261.139     -13261.139      291.11237      291.11237      67330.259      67330.259     -1002.1525     -1002.1525    
     13000  -13109.283     -13109.283     -13259.862     -13259.862      291.30414      291.30414      67286.084      67286.084     -391.16869     -391.16869    
Loop time of 79.4782 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.087 ns/day, 22.077 hours/ns, 12.582 timesteps/s
99.2% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 79.283     | 79.283     | 79.283     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.035766   | 0.035766   | 0.035766   |   0.0 |  0.05
Output  | 7.8728e-05 | 7.8728e-05 | 7.8728e-05 |   0.0 |  0.00
Modify  | 0.14409    | 0.14409    | 0.14409    |   0.0 |  0.18
Other   |            | 0.0155     |            |       |  0.02

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

Total # of neighbors = 323122
Ave neighs/atom = 80.7805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.325892695697, Press = 1.61797719476465
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13109.283     -13109.283     -13259.862     -13259.862      291.30414      291.30414      67286.084      67286.084     -391.16869     -391.16869    
     14000  -13101.155     -13101.155     -13253.154     -13253.154      294.05352      294.05352      67272.345      67272.345      80.182384      80.182384    
Loop time of 78.8732 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.095 ns/day, 21.909 hours/ns, 12.679 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 78.691     | 78.691     | 78.691     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025623   | 0.025623   | 0.025623   |   0.0 |  0.03
Output  | 0.00014646 | 0.00014646 | 0.00014646 |   0.0 |  0.00
Modify  | 0.14097    | 0.14097    | 0.14097    |   0.0 |  0.18
Other   |            | 0.0154     |            |       |  0.02

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

Total # of neighbors = 323352
Ave neighs/atom = 80.838
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.483908013858, Press = 0.585056481360082
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13101.155     -13101.155     -13253.154     -13253.154      294.05352      294.05352      67272.345      67272.345      80.182384      80.182384    
     15000  -13105.521     -13105.521     -13259.964     -13259.964      298.78008      298.78008      67241.38       67241.38       140.4337       140.4337     
Loop time of 76.594 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.128 ns/day, 21.276 hours/ns, 13.056 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 76.416     | 76.416     | 76.416     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024567   | 0.024567   | 0.024567   |   0.0 |  0.03
Output  | 7.6454e-05 | 7.6454e-05 | 7.6454e-05 |   0.0 |  0.00
Modify  | 0.13819    | 0.13819    | 0.13819    |   0.0 |  0.18
Other   |            | 0.01527    |            |       |  0.02

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

Total # of neighbors = 323360
Ave neighs/atom = 80.84
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.524653178693, Press = -0.463037379443744
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13105.521     -13105.521     -13259.964     -13259.964      298.78008      298.78008      67241.38       67241.38       140.4337       140.4337     
     16000  -13106.187     -13106.187     -13257.295     -13257.295      292.32849      292.32849      67234.679      67234.679      308.82166      308.82166    
Loop time of 74.2195 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.164 ns/day, 20.617 hours/ns, 13.474 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.042     | 74.042     | 74.042     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024379   | 0.024379   | 0.024379   |   0.0 |  0.03
Output  | 8.0401e-05 | 8.0401e-05 | 8.0401e-05 |   0.0 |  0.00
Modify  | 0.13704    | 0.13704    | 0.13704    |   0.0 |  0.18
Other   |            | 0.01556    |            |       |  0.02

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

Total # of neighbors = 323370
Ave neighs/atom = 80.8425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.519713170209, Press = -0.579605219285014
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13106.187     -13106.187     -13257.295     -13257.295      292.32849      292.32849      67234.679      67234.679      308.82166      308.82166    
     17000  -13109.005     -13109.005     -13258.482     -13258.482      289.17259      289.17259      67151.813      67151.813      1190.0566      1190.0566    
Loop time of 74.1955 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.164 ns/day, 20.610 hours/ns, 13.478 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.021     | 74.021     | 74.021     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023997   | 0.023997   | 0.023997   |   0.0 |  0.03
Output  | 7.7025e-05 | 7.7025e-05 | 7.7025e-05 |   0.0 |  0.00
Modify  | 0.13593    | 0.13593    | 0.13593    |   0.0 |  0.18
Other   |            | 0.01476    |            |       |  0.02

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

Total # of neighbors = 323462
Ave neighs/atom = 80.8655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.398691682947, Press = 0.427371877600035
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13109.005     -13109.005     -13258.482     -13258.482      289.17259      289.17259      67151.813      67151.813      1190.0566      1190.0566    
     18000  -13103.631     -13103.631     -13257.777     -13257.777      298.20468      298.20468      67124.03       67124.03       1616.8752      1616.8752    
Loop time of 73.8555 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.170 ns/day, 20.515 hours/ns, 13.540 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.697     | 73.697     | 73.697     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022075   | 0.022075   | 0.022075   |   0.0 |  0.03
Output  | 6.9421e-05 | 6.9421e-05 | 6.9421e-05 |   0.0 |  0.00
Modify  | 0.12563    | 0.12563    | 0.12563    |   0.0 |  0.17
Other   |            | 0.01113    |            |       |  0.02

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

Total # of neighbors = 323808
Ave neighs/atom = 80.952
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.456166708412, Press = -0.686008939270512
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13103.631     -13103.631     -13257.777     -13257.777      298.20468      298.20468      67124.03       67124.03       1616.8752      1616.8752    
     19000  -13106.396     -13106.396     -13258.18      -13258.18       293.63586      293.63586      67171.963      67171.963      1016.5703      1016.5703    
Loop time of 74.185 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.165 ns/day, 20.607 hours/ns, 13.480 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.011     | 74.011     | 74.011     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023926   | 0.023926   | 0.023926   |   0.0 |  0.03
Output  | 7.6213e-05 | 7.6213e-05 | 7.6213e-05 |   0.0 |  0.00
Modify  | 0.13569    | 0.13569    | 0.13569    |   0.0 |  0.18
Other   |            | 0.01423    |            |       |  0.02

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

Total # of neighbors = 323840
Ave neighs/atom = 80.96
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.491933757973, Press = -1.39817664639893
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13106.396     -13106.396     -13258.18      -13258.18       293.63586      293.63586      67171.963      67171.963      1016.5703      1016.5703    
     20000  -13107.179     -13107.179     -13260.425     -13260.425      296.46454      296.46454      67207.271      67207.271      535.19201      535.19201    
Loop time of 73.7751 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.171 ns/day, 20.493 hours/ns, 13.555 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.612     | 73.612     | 73.612     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022862   | 0.022862   | 0.022862   |   0.0 |  0.03
Output  | 5.8329e-05 | 5.8329e-05 | 5.8329e-05 |   0.0 |  0.00
Modify  | 0.12842    | 0.12842    | 0.12842    |   0.0 |  0.17
Other   |            | 0.01213    |            |       |  0.02

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

Total # of neighbors = 323648
Ave neighs/atom = 80.912
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.513976432078, Press = -2.01046740994733
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13107.179     -13107.179     -13260.425     -13260.425      296.46454      296.46454      67207.271      67207.271      535.19201      535.19201    
     21000  -13106.444     -13106.444     -13258.723     -13258.723      294.5928       294.5928       67224.903      67224.903      383.40745      383.40745    
Loop time of 73.8728 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.170 ns/day, 20.520 hours/ns, 13.537 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.713     | 73.713     | 73.713     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022068   | 0.022068   | 0.022068   |   0.0 |  0.03
Output  | 6.7086e-05 | 6.7086e-05 | 6.7086e-05 |   0.0 |  0.00
Modify  | 0.126      | 0.126      | 0.126      |   0.0 |  0.17
Other   |            | 0.01119    |            |       |  0.02

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

Total # of neighbors = 323492
Ave neighs/atom = 80.873
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.424246652491, Press = -1.90657335455582
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13106.444     -13106.444     -13258.723     -13258.723      294.5928       294.5928       67224.903      67224.903      383.40745      383.40745    
     22000  -13102.974     -13102.974     -13254.656     -13254.656      293.43794      293.43794      67233.173      67233.173      459.79318      459.79318    
Loop time of 74.0808 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.166 ns/day, 20.578 hours/ns, 13.499 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.915     | 73.915     | 73.915     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022596   | 0.022596   | 0.022596   |   0.0 |  0.03
Output  | 7.8568e-05 | 7.8568e-05 | 7.8568e-05 |   0.0 |  0.00
Modify  | 0.12975    | 0.12975    | 0.12975    |   0.0 |  0.18
Other   |            | 0.01291    |            |       |  0.02

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

Total # of neighbors = 323452
Ave neighs/atom = 80.863
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.503282109945, Press = -2.39036096544556
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13102.974     -13102.974     -13254.656     -13254.656      293.43794      293.43794      67233.173      67233.173      459.79318      459.79318    
     23000  -13109.121     -13109.121     -13259.183     -13259.183      290.30532      290.30532      67236.716      67236.716      210.02531      210.02531    
Loop time of 73.8106 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.171 ns/day, 20.503 hours/ns, 13.548 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.65      | 73.65      | 73.65      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022407   | 0.022407   | 0.022407   |   0.0 |  0.03
Output  | 7.494e-05  | 7.494e-05  | 7.494e-05  |   0.0 |  0.00
Modify  | 0.12718    | 0.12718    | 0.12718    |   0.0 |  0.17
Other   |            | 0.01142    |            |       |  0.02

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

Total # of neighbors = 323370
Ave neighs/atom = 80.8425
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.495864619258, Press = -2.94310779892153
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13109.121     -13109.121     -13259.183     -13259.183      290.30532      290.30532      67236.716      67236.716      210.02531      210.02531    
     24000  -13100.802     -13100.802     -13253.27      -13253.27       294.95947      294.95947      67308.843      67308.843     -322.13747     -322.13747    
Loop time of 74.1204 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.166 ns/day, 20.589 hours/ns, 13.492 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.937     | 73.937     | 73.937     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025243   | 0.025243   | 0.025243   |   0.0 |  0.03
Output  | 6.7516e-05 | 6.7516e-05 | 6.7516e-05 |   0.0 |  0.00
Modify  | 0.14084    | 0.14084    | 0.14084    |   0.0 |  0.19
Other   |            | 0.0168     |            |       |  0.02

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

Total # of neighbors = 323550
Ave neighs/atom = 80.8875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.592404873826, Press = -3.77581385253851
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13100.802     -13100.802     -13253.27      -13253.27       294.95947      294.95947      67308.843      67308.843     -322.13747     -322.13747    
     25000  -13105.944     -13105.944     -13258.373     -13258.373      294.88539      294.88539      67338.067      67338.067     -944.35895     -944.35895    
Loop time of 73.9911 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.168 ns/day, 20.553 hours/ns, 13.515 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.807     | 73.807     | 73.807     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025293   | 0.025293   | 0.025293   |   0.0 |  0.03
Output  | 7.2877e-05 | 7.2877e-05 | 7.2877e-05 |   0.0 |  0.00
Modify  | 0.14244    | 0.14244    | 0.14244    |   0.0 |  0.19
Other   |            | 0.01669    |            |       |  0.02

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

Total # of neighbors = 323184
Ave neighs/atom = 80.796
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.604099926291, Press = -2.99932107427247
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13105.944     -13105.944     -13258.373     -13258.373      294.88539      294.88539      67338.067      67338.067     -944.35895     -944.35895    
     26000  -13105.813     -13105.813     -13258.133     -13258.133      294.67408      294.67408      67310.523      67310.523     -591.43594     -591.43594    
Loop time of 73.9648 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.168 ns/day, 20.546 hours/ns, 13.520 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.78      | 73.78      | 73.78      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02549    | 0.02549    | 0.02549    |   0.0 |  0.03
Output  | 8.9958e-05 | 8.9958e-05 | 8.9958e-05 |   0.0 |  0.00
Modify  | 0.14192    | 0.14192    | 0.14192    |   0.0 |  0.19
Other   |            | 0.01698    |            |       |  0.02

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

Total # of neighbors = 323012
Ave neighs/atom = 80.753
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.6365958081, Press = -1.21523048577251
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13105.813     -13105.813     -13258.133     -13258.133      294.67408      294.67408      67310.523      67310.523     -591.43594     -591.43594    
     27000  -13108.444     -13108.444     -13258.411     -13258.411      290.12032      290.12032      67296.28       67296.28      -498.37115     -498.37115    
Loop time of 74.2429 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.164 ns/day, 20.623 hours/ns, 13.469 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 74.06      | 74.06      | 74.06      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025075   | 0.025075   | 0.025075   |   0.0 |  0.03
Output  | 8.3917e-05 | 8.3917e-05 | 8.3917e-05 |   0.0 |  0.00
Modify  | 0.14096    | 0.14096    | 0.14096    |   0.0 |  0.19
Other   |            | 0.01685    |            |       |  0.02

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

Total # of neighbors = 323306
Ave neighs/atom = 80.8265
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.683317764609, Press = -0.934840247012548
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13108.444     -13108.444     -13258.411     -13258.411      290.12032      290.12032      67296.28       67296.28      -498.37115     -498.37115    
     28000  -13110.851     -13110.851     -13260.007     -13260.007      288.55073      288.55073      67302.218      67302.218     -660.83665     -660.83665    
Loop time of 74.0031 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.168 ns/day, 20.556 hours/ns, 13.513 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.82      | 73.82      | 73.82      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.025518   | 0.025518   | 0.025518   |   0.0 |  0.03
Output  | 7.8858e-05 | 7.8858e-05 | 7.8858e-05 |   0.0 |  0.00
Modify  | 0.14085    | 0.14085    | 0.14085    |   0.0 |  0.19
Other   |            | 0.01699    |            |       |  0.02

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

Total # of neighbors = 323190
Ave neighs/atom = 80.7975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.694354883567, Press = -0.778731803931913
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13110.851     -13110.851     -13260.007     -13260.007      288.55073      288.55073      67302.218      67302.218     -660.83665     -660.83665    
     29000  -13107.571     -13107.571     -13257.657     -13257.657      290.35195      290.35195      67347.672      67347.672     -1051.5327     -1051.5327    
Loop time of 73.8885 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.169 ns/day, 20.525 hours/ns, 13.534 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.728     | 73.728     | 73.728     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022227   | 0.022227   | 0.022227   |   0.0 |  0.03
Output  | 8.0451e-05 | 8.0451e-05 | 8.0451e-05 |   0.0 |  0.00
Modify  | 0.12711    | 0.12711    | 0.12711    |   0.0 |  0.17
Other   |            | 0.01151    |            |       |  0.02

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

Total # of neighbors = 323124
Ave neighs/atom = 80.781
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.627813131605, Press = 0.196469341641223
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13107.571     -13107.571     -13257.657     -13257.657      290.35195      290.35195      67347.672      67347.672     -1051.5327     -1051.5327    
     30000  -13106.853     -13106.853     -13258.26      -13258.26       292.90619      292.90619      67348.961      67348.961     -1076.8343     -1076.8343    
Loop time of 73.3916 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.177 ns/day, 20.387 hours/ns, 13.626 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.234     | 73.234     | 73.234     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022131   | 0.022131   | 0.022131   |   0.0 |  0.03
Output  | 5.4473e-05 | 5.4473e-05 | 5.4473e-05 |   0.0 |  0.00
Modify  | 0.12437    | 0.12437    | 0.12437    |   0.0 |  0.17
Other   |            | 0.01122    |            |       |  0.02

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

Total # of neighbors = 323134
Ave neighs/atom = 80.7835
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.642661147159, Press = 1.21132652238417
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13106.853     -13106.853     -13258.26      -13258.26       292.90619      292.90619      67348.961      67348.961     -1076.8343     -1076.8343    
     31000  -13104.84      -13104.84      -13254.919     -13254.919      290.33925      290.33925      67280.514      67280.514     -82.659648     -82.659648    
Loop time of 73.1593 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.181 ns/day, 20.322 hours/ns, 13.669 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 72.999     | 72.999     | 72.999     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024051   | 0.024051   | 0.024051   |   0.0 |  0.03
Output  | 6.6675e-05 | 6.6675e-05 | 6.6675e-05 |   0.0 |  0.00
Modify  | 0.12522    | 0.12522    | 0.12522    |   0.0 |  0.17
Other   |            | 0.01116    |            |       |  0.02

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

Total # of neighbors = 323108
Ave neighs/atom = 80.777
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.656899236614, Press = 0.925066214916148
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13104.84      -13104.84      -13254.919     -13254.919      290.33925      290.33925      67280.514      67280.514     -82.659648     -82.659648    
     32000  -13108.117     -13108.117     -13258.454     -13258.454      290.83759      290.83759      67240.322      67240.322      150.26563      150.26563    
Loop time of 73.1613 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.181 ns/day, 20.323 hours/ns, 13.668 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.005     | 73.005     | 73.005     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022425   | 0.022425   | 0.022425   |   0.0 |  0.03
Output  | 5.6096e-05 | 5.6096e-05 | 5.6096e-05 |   0.0 |  0.00
Modify  | 0.12335    | 0.12335    | 0.12335    |   0.0 |  0.17
Other   |            | 0.01086    |            |       |  0.01

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

Total # of neighbors = 323330
Ave neighs/atom = 80.8325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.708110884275, Press = 0.572186114055941
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13108.117     -13108.117     -13258.454     -13258.454      290.83759      290.83759      67240.322      67240.322      150.26563      150.26563    
     33000  -13100.734     -13100.734     -13253.794     -13253.794      296.10459      296.10459      67237.942      67237.942      468.23797      468.23797    
Loop time of 73.3955 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.177 ns/day, 20.388 hours/ns, 13.625 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.239     | 73.239     | 73.239     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022465   | 0.022465   | 0.022465   |   0.0 |  0.03
Output  | 0.00016414 | 0.00016414 | 0.00016414 |   0.0 |  0.00
Modify  | 0.12316    | 0.12316    | 0.12316    |   0.0 |  0.17
Other   |            | 0.01071    |            |       |  0.01

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

Total # of neighbors = 323324
Ave neighs/atom = 80.831
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.7721081145, Press = 0.495536420167801
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13100.734     -13100.734     -13253.794     -13253.794      296.10459      296.10459      67237.942      67237.942      468.23797      468.23797    
     34000  -13109.242     -13109.242     -13261.128     -13261.128      293.8336       293.8336       67179.653      67179.653      771.71076      771.71076    
Loop time of 73.3697 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.178 ns/day, 20.380 hours/ns, 13.630 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.214     | 73.214     | 73.214     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022144   | 0.022144   | 0.022144   |   0.0 |  0.03
Output  | 5.7518e-05 | 5.7518e-05 | 5.7518e-05 |   0.0 |  0.00
Modify  | 0.12265    | 0.12265    | 0.12265    |   0.0 |  0.17
Other   |            | 0.01075    |            |       |  0.01

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

Total # of neighbors = 323408
Ave neighs/atom = 80.852
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.823022139266, Press = 0.305115436096355
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13109.242     -13109.242     -13261.128     -13261.128      293.8336       293.8336       67179.653      67179.653      771.71076      771.71076    
     35000  -13105.482     -13105.482     -13258.048     -13258.048      295.14956      295.14956      67198.515      67198.515      759.35269      759.35269    
Loop time of 73.3987 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.177 ns/day, 20.389 hours/ns, 13.624 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.239     | 73.239     | 73.239     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023351   | 0.023351   | 0.023351   |   0.0 |  0.03
Output  | 7.0172e-05 | 7.0172e-05 | 7.0172e-05 |   0.0 |  0.00
Modify  | 0.1249     | 0.1249     | 0.1249     |   0.0 |  0.17
Other   |            | 0.01106    |            |       |  0.02

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

Total # of neighbors = 323598
Ave neighs/atom = 80.8995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.87721213582, Press = -0.269944942268156
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13105.482     -13105.482     -13258.048     -13258.048      295.14956      295.14956      67198.515      67198.515      759.35269      759.35269    
     36000  -13106.621     -13106.621     -13256.954     -13256.954      290.82979      290.82979      67218.563      67218.563      510.56617      510.56617    
Loop time of 73.2947 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.179 ns/day, 20.360 hours/ns, 13.644 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.137     | 73.137     | 73.137     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02242    | 0.02242    | 0.02242    |   0.0 |  0.03
Output  | 7.1805e-05 | 7.1805e-05 | 7.1805e-05 |   0.0 |  0.00
Modify  | 0.12405    | 0.12405    | 0.12405    |   0.0 |  0.17
Other   |            | 0.01107    |            |       |  0.02

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

Total # of neighbors = 323440
Ave neighs/atom = 80.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 = 292.935625370748, Press = -0.483024139633076
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13106.621     -13106.621     -13256.954     -13256.954      290.82979      290.82979      67218.563      67218.563      510.56617      510.56617    
     37000  -13101.743     -13101.743     -13258.429     -13258.429      303.12092      303.12092      67254.464      67254.464      136.87784      136.87784    
Loop time of 73.258 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.179 ns/day, 20.349 hours/ns, 13.650 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.104     | 73.104     | 73.104     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0217     | 0.0217     | 0.0217     |   0.0 |  0.03
Output  | 5.0044e-05 | 5.0044e-05 | 5.0044e-05 |   0.0 |  0.00
Modify  | 0.1219     | 0.1219     | 0.1219     |   0.0 |  0.17
Other   |            | 0.01061    |            |       |  0.01

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

Total # of neighbors = 323498
Ave neighs/atom = 80.8745
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.954625165314, Press = -0.532732375471585
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13101.743     -13101.743     -13258.429     -13258.429      303.12092      303.12092      67254.464      67254.464      136.87784      136.87784    
     38000  -13107.007     -13107.007     -13259.216     -13259.216      294.45743      294.45743      67234.289      67234.289      248.72671      248.72671    
Loop time of 73.1209 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.182 ns/day, 20.311 hours/ns, 13.676 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 72.967     | 72.967     | 72.967     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021649   | 0.021649   | 0.021649   |   0.0 |  0.03
Output  | 5.8539e-05 | 5.8539e-05 | 5.8539e-05 |   0.0 |  0.00
Modify  | 0.12175    | 0.12175    | 0.12175    |   0.0 |  0.17
Other   |            | 0.0105     |            |       |  0.01

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

Total # of neighbors = 323252
Ave neighs/atom = 80.813
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.999514586916, Press = -0.52237940646726
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13107.007     -13107.007     -13259.216     -13259.216      294.45743      294.45743      67234.289      67234.289      248.72671      248.72671    
     39000  -13098.964     -13098.964     -13255.196     -13255.196      302.2417       302.2417       67204.967      67204.967      813.43818      813.43818    
Loop time of 73.1563 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.181 ns/day, 20.321 hours/ns, 13.669 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.002     | 73.002     | 73.002     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021804   | 0.021804   | 0.021804   |   0.0 |  0.03
Output  | 4.8771e-05 | 4.8771e-05 | 4.8771e-05 |   0.0 |  0.00
Modify  | 0.12185    | 0.12185    | 0.12185    |   0.0 |  0.17
Other   |            | 0.01051    |            |       |  0.01

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

Total # of neighbors = 323292
Ave neighs/atom = 80.823
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.03709919852, Press = -0.772026367697286
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13098.964     -13098.964     -13255.196     -13255.196      302.2417       302.2417       67204.967      67204.967      813.43818      813.43818    
     40000  -13109.283     -13109.283     -13260.312     -13260.312      292.17567      292.17567      67168.896      67168.896      944.88342      944.88342    
Loop time of 73.4492 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.176 ns/day, 20.403 hours/ns, 13.615 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.29      | 73.29      | 73.29      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023387   | 0.023387   | 0.023387   |   0.0 |  0.03
Output  | 5.335e-05  | 5.335e-05  | 5.335e-05  |   0.0 |  0.00
Modify  | 0.12482    | 0.12482    | 0.12482    |   0.0 |  0.17
Other   |            | 0.01102    |            |       |  0.01

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

Total # of neighbors = 323596
Ave neighs/atom = 80.899
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.076804547904, Press = -1.20146663544832
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13109.283     -13109.283     -13260.312     -13260.312      292.17567      292.17567      67168.896      67168.896      944.88342      944.88342    
     41000  -13104.29      -13104.29      -13256.719     -13256.719      294.88276      294.88276      67227.596      67227.596      459.75458      459.75458    
Loop time of 73.8723 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.170 ns/day, 20.520 hours/ns, 13.537 timesteps/s
99.3% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.707     | 73.707     | 73.707     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02543    | 0.02543    | 0.02543    |   0.0 |  0.03
Output  | 0.0001543  | 0.0001543  | 0.0001543  |   0.0 |  0.00
Modify  | 0.12831    | 0.12831    | 0.12831    |   0.0 |  0.17
Other   |            | 0.01166    |            |       |  0.02

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

Total # of neighbors = 323582
Ave neighs/atom = 80.8955
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.096412283184, Press = -1.24432558790623
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13104.29      -13104.29      -13256.719     -13256.719      294.88276      294.88276      67227.596      67227.596      459.75458      459.75458    
     42000  -13104.053     -13104.053     -13254.984     -13254.984      291.98562      291.98562      67256.219      67256.219      215.77501      215.77501    
Loop time of 73.5128 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.175 ns/day, 20.420 hours/ns, 13.603 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.35      | 73.35      | 73.35      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.024631   | 0.024631   | 0.024631   |   0.0 |  0.03
Output  | 0.00015653 | 0.00015653 | 0.00015653 |   0.0 |  0.00
Modify  | 0.12677    | 0.12677    | 0.12677    |   0.0 |  0.17
Other   |            | 0.01137    |            |       |  0.02

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

Total # of neighbors = 323436
Ave neighs/atom = 80.859
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.100651862185, Press = -0.877285305743135
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13104.053     -13104.053     -13254.984     -13254.984      291.98562      291.98562      67256.219      67256.219      215.77501      215.77501    
     43000  -13107.434     -13107.434     -13258.687     -13258.687      292.60929      292.60929      67258.618      67258.618     -5.9299708     -5.9299708    
Loop time of 73.3757 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.178 ns/day, 20.382 hours/ns, 13.628 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.211     | 73.211     | 73.211     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02511    | 0.02511    | 0.02511    |   0.0 |  0.03
Output  | 5.2178e-05 | 5.2178e-05 | 5.2178e-05 |   0.0 |  0.00
Modify  | 0.12794    | 0.12794    | 0.12794    |   0.0 |  0.17
Other   |            | 0.01142    |            |       |  0.02

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

Total # of neighbors = 323418
Ave neighs/atom = 80.8545
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.146737039386, Press = -0.735437875245844
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13107.434     -13107.434     -13258.687     -13258.687      292.60929      292.60929      67258.618      67258.618     -5.9299708     -5.9299708    
     44000  -13101.194     -13101.194     -13254.66      -13254.66       296.89037      296.89037      67273.727      67273.727     -2.3627959     -2.3627959    
Loop time of 72.8537 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.186 ns/day, 20.237 hours/ns, 13.726 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 72.698     | 72.698     | 72.698     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.022012   | 0.022012   | 0.022012   |   0.0 |  0.03
Output  | 0.00010716 | 0.00010716 | 0.00010716 |   0.0 |  0.00
Modify  | 0.12249    | 0.12249    | 0.12249    |   0.0 |  0.17
Other   |            | 0.01069    |            |       |  0.01

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

Total # of neighbors = 323398
Ave neighs/atom = 80.8495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.183578536088, Press = -0.588306232446898
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13101.194     -13101.194     -13254.66      -13254.66       296.89037      296.89037      67273.727      67273.727     -2.3627959     -2.3627959    
     45000  -13105.034     -13105.034     -13258.232     -13258.232      296.37316      296.37316      67266.417      67266.417     -57.76151      -57.76151     
Loop time of 72.9987 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.184 ns/day, 20.277 hours/ns, 13.699 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 72.84      | 72.84      | 72.84      |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.023049   | 0.023049   | 0.023049   |   0.0 |  0.03
Output  | 5.5864e-05 | 5.5864e-05 | 5.5864e-05 |   0.0 |  0.00
Modify  | 0.12433    | 0.12433    | 0.12433    |   0.0 |  0.17
Other   |            | 0.01115    |            |       |  0.02

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

Total # of neighbors = 323262
Ave neighs/atom = 80.8155
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.175067527246, Press = -0.458786598794052
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13105.034     -13105.034     -13258.232     -13258.232      296.37316      296.37316      67266.417      67266.417     -57.76151      -57.76151     
     46000  -13105.36      -13105.36      -13256.68      -13256.68       292.73985      292.73985      67266.757      67266.757      5.3968477      5.3968477    
Loop time of 72.8125 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.187 ns/day, 20.226 hours/ns, 13.734 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 72.657     | 72.657     | 72.657     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.02219    | 0.02219    | 0.02219    |   0.0 |  0.03
Output  | 7.0122e-05 | 7.0122e-05 | 7.0122e-05 |   0.0 |  0.00
Modify  | 0.12263    | 0.12263    | 0.12263    |   0.0 |  0.17
Other   |            | 0.0108     |            |       |  0.01

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

Total # of neighbors = 323388
Ave neighs/atom = 80.847
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.20328580723, Press = -0.525095149674622
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13105.36      -13105.36      -13256.68      -13256.68       292.73985      292.73985      67266.757      67266.757      5.3968477      5.3968477    
     47000  -13103.641     -13103.641     -13258.855     -13258.855      300.27322      300.27322      67286.214      67286.214     -302.52123     -302.52123    
Loop time of 72.8323 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.186 ns/day, 20.231 hours/ns, 13.730 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 72.679     | 72.679     | 72.679     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021672   | 0.021672   | 0.021672   |   0.0 |  0.03
Output  | 7.0693e-05 | 7.0693e-05 | 7.0693e-05 |   0.0 |  0.00
Modify  | 0.12101    | 0.12101    | 0.12101    |   0.0 |  0.17
Other   |            | 0.01045    |            |       |  0.01

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

Total # of neighbors = 323334
Ave neighs/atom = 80.8335
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.207870776898, Press = -0.492333884959545
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13103.641     -13103.641     -13258.855     -13258.855      300.27322      300.27322      67286.214      67286.214     -302.52123     -302.52123    
     48000  -13107.55      -13107.55      -13258.716     -13258.716      292.44017      292.44017      67285.026      67285.026     -355.90655     -355.90655    
Loop time of 72.949 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.184 ns/day, 20.264 hours/ns, 13.708 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 72.796     | 72.796     | 72.796     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021523   | 0.021523   | 0.021523   |   0.0 |  0.03
Output  | 7.7165e-05 | 7.7165e-05 | 7.7165e-05 |   0.0 |  0.00
Modify  | 0.12115    | 0.12115    | 0.12115    |   0.0 |  0.17
Other   |            | 0.01044    |            |       |  0.01

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

Total # of neighbors = 323244
Ave neighs/atom = 80.811
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.239294668213, Press = -0.459088306579129
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13107.55      -13107.55      -13258.716     -13258.716      292.44017      292.44017      67285.026      67285.026     -355.90655     -355.90655    
     49000  -13101.445     -13101.445     -13255.286     -13255.286      297.61497      297.61497      67328.015      67328.015     -663.90657     -663.90657    
Loop time of 72.7836 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.187 ns/day, 20.218 hours/ns, 13.739 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 72.631     | 72.631     | 72.631     |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021579   | 0.021579   | 0.021579   |   0.0 |  0.03
Output  | 7.6564e-05 | 7.6564e-05 | 7.6564e-05 |   0.0 |  0.00
Modify  | 0.12098    | 0.12098    | 0.12098    |   0.0 |  0.17
Other   |            | 0.01034    |            |       |  0.01

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

Total # of neighbors = 323340
Ave neighs/atom = 80.835
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.271618798591, Press = -0.291467631365436
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      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  -13101.445     -13101.445     -13255.286     -13255.286      297.61497      297.61497      67328.015      67328.015     -663.90657     -663.90657    
     50000  -13106.015     -13106.015     -13256.896     -13256.896      291.88897      291.88897      67310.009      67310.009     -519.80789     -519.80789    
Loop time of 72.8936 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.185 ns/day, 20.248 hours/ns, 13.719 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 72.74      | 72.74      | 72.74      |   0.0 | 99.79
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.021625   | 0.021625   | 0.021625   |   0.0 |  0.03
Output  | 6.3138e-05 | 6.3138e-05 | 6.3138e-05 |   0.0 |  0.00
Modify  | 0.12129    | 0.12129    | 0.12129    |   0.0 |  0.17
Other   |            | 0.01037    |            |       |  0.01

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

Total # of neighbors = 323300
Ave neighs/atom = 80.825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
67259.7326487473

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0