# 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.0499990060925475*${_u_distance}
variable latticeconst_converted equal 4.0499990060925475*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04999900609255
Lattice spacing in x,y,z = 4.049999 4.049999 4.049999
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (40.49999 40.49999 40.49999)
  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.49999 40.49999 40.49999)
  create_atoms CPU = 0.005 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_DickelBaskesAslam_2018_MgAlZn__MO_093637366498_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.0760923112    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66430.0760923112/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66430.0760923112/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 66430.0760923112/(1*1*${_u_distance})
variable      V0_metal equal 66430.0760923112/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 66430.0760923112*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66430.0760923112 Angstroms^3

# set the time step to 0.001 picoseconds
variable timestep_converted equal 0.001*${_u_time}
variable timestep_converted equal 0.001*1
timestep ${timestep_converted}
timestep 0.001

variable temp_converted equal 313.15*${_u_temperature}
variable temp_converted equal 313.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

# create initial velocities consistent with the chosen temperature
velocity      all create ${temp_converted} 17 mom yes rot yes
velocity      all create 313.15 17 mom yes rot yes

# set NPT ensemble for all atoms
fix           ensemble all npt temp ${temp_converted} ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 1

# compute the time averages of pressure, temperature, and volume, respectively
# ignore the first 5000 timesteps
variable      etotal_metal equal etotal/${_u_energy}
variable      etotal_metal equal etotal/1
variable      pe_metal equal pe/${_u_energy}
variable      pe_metal equal pe/1
variable      T_metal equal temp/${_u_temperature}
variable      T_metal equal temp/1
variable      V_metal equal vol/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*1*${_u_distance})
variable      V_metal equal vol/(1*1*1)
variable      P_metal equal press/${_u_pressure}
variable      P_metal equal press/1
fix           avgmyTemp  all ave/time 5 20 100 v_T_metal  ave running start 5000
fix           avgmyPress all ave/time 5 20 100 v_P_metal ave running start 5000
fix           avgmyVol   all ave/time 5 20 100 v_V_metal   ave running start 5000

# extract fix quantities into variables so they can be used in if-else logic later.
variable      T equal f_avgmyTemp
variable      P equal f_avgmyPress
variable      V equal f_avgmyVol

# set error bounds for temperature and pressure in original metal units (K and bar)
variable      T_low equal  "313.15 - 0.2"
variable      T_up  equal  "313.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

# print to logfile every 1000 timesteps
thermo_style  custom step etotal v_etotal_metal pe v_pe_metal               temp v_T_metal vol v_V_metal press v_P_metal
thermo        1000

# Run a simulation for at most 2000*1000 timesteps. At each 1000th time step, check
# whether the temperature and pressure have converged. If yes, break.
label top
variable a loop 2000
run 1000

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

Your simulation uses code contributions which should be cited:

- OpenKIM: https://doi.org/10.1007/s11837-011-0102-6

@Article{tadmor:elliott:2011,
 author = {E. B. Tadmor and R. S. Elliott and J. P. Sethna and R. E. Miller and C. A. Becker},
 title = {The potential of atomistic simulations and the {K}nowledgebase of {I}nteratomic {M}odels},
 journal = {{JOM}},
 year =    2011,
 volume =  63,
 number =  17,
 pages =   {17},
 doi =     {10.1007/s11837-011-0102-6}
}

- OpenKIM potential: https://openkim.org/cite/MO_093637366498_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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -13278.129     -13278.129     -13440         -13440          313.15         313.15         66430.076      66430.076      2602.7061      2602.7061    
      1000  -13102.77      -13102.77      -13274.126     -13274.126      331.49868      331.49868      67631.572      67631.572      313.17392      313.17392    
Loop time of 649.253 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.348 hours/ns, 1.540 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 648.34     | 648.34     | 648.34     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14918    | 0.14918    | 0.14918    |   0.0 |  0.02
Output  | 0.00028937 | 0.00028937 | 0.00028937 |   0.0 |  0.00
Modify  | 0.66915    | 0.66915    | 0.66915    |   0.0 |  0.10
Other   |            | 0.09648    |            |       |  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:       536000 ave      536000 max      536000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 536000
Ave neighs/atom = 134
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13102.77      -13102.77      -13274.126     -13274.126      331.49868      331.49868      67631.572      67631.572      313.17392      313.17392    
      2000  -13117.504     -13117.504     -13279.45      -13279.45       313.29592      313.29592      67649.125      67649.125     -475.28093     -475.28093    
Loop time of 741.985 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.116 ns/day, 206.107 hours/ns, 1.348 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 740.94     | 740.94     | 740.94     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16489    | 0.16489    | 0.16489    |   0.0 |  0.02
Output  | 0.00023647 | 0.00023647 | 0.00023647 |   0.0 |  0.00
Modify  | 0.77565    | 0.77565    | 0.77565    |   0.0 |  0.10
Other   |            | 0.1047     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5927 ave        5927 max        5927 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538580 ave      538580 max      538580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538580
Ave neighs/atom = 134.645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13117.504     -13117.504     -13279.45      -13279.45       313.29592      313.29592      67649.125      67649.125     -475.28093     -475.28093    
      3000  -13111.123     -13111.123     -13271.405     -13271.405      310.07757      310.07757      67671.765      67671.765     -238.47275     -238.47275    
Loop time of 761.931 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.113 ns/day, 211.647 hours/ns, 1.312 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 760.85     | 760.85     | 760.85     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16908    | 0.16908    | 0.16908    |   0.0 |  0.02
Output  | 0.0002329  | 0.0002329  | 0.0002329  |   0.0 |  0.00
Modify  | 0.80679    | 0.80679    | 0.80679    |   0.0 |  0.11
Other   |            | 0.1079     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6000 ave        6000 max        6000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538544 ave      538544 max      538544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538544
Ave neighs/atom = 134.636
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13111.123     -13111.123     -13271.405     -13271.405      310.07757      310.07757      67671.765      67671.765     -238.47275     -238.47275    
      4000  -13111.857     -13111.857     -13279.233     -13279.233      323.80032      323.80032      67677.188      67677.188     -677.56305     -677.56305    
Loop time of 680.434 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.127 ns/day, 189.009 hours/ns, 1.470 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 679.5      | 679.5      | 679.5      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15417    | 0.15417    | 0.15417    |   0.0 |  0.02
Output  | 0.00030128 | 0.00030128 | 0.00030128 |   0.0 |  0.00
Modify  | 0.68564    | 0.68564    | 0.68564    |   0.0 |  0.10
Other   |            | 0.09746    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5948 ave        5948 max        5948 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538578 ave      538578 max      538578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538578
Ave neighs/atom = 134.6445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13111.857     -13111.857     -13279.233     -13279.233      323.80032      323.80032      67677.188      67677.188     -677.56305     -677.56305    
      5000  -13113.919     -13113.919     -13272.554     -13272.554      306.89082      306.89082      67611.408      67611.408      410.01963      410.01963    
Loop time of 750.111 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.115 ns/day, 208.364 hours/ns, 1.333 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 749.04     | 749.04     | 749.04     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17049    | 0.17049    | 0.17049    |   0.0 |  0.02
Output  | 0.00019128 | 0.00019128 | 0.00019128 |   0.0 |  0.00
Modify  | 0.79417    | 0.79417    | 0.79417    |   0.0 |  0.11
Other   |            | 0.1055     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5974 ave        5974 max        5974 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538492 ave      538492 max      538492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538492
Ave neighs/atom = 134.623
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.248278420979, Press = 368.169691777607
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13113.919     -13113.919     -13272.554     -13272.554      306.89082      306.89082      67611.408      67611.408      410.01963      410.01963    
      6000  -13110.71      -13110.71      -13272.018     -13272.018      312.06199      312.06199      67583.018      67583.018      806.36198      806.36198    
Loop time of 714.358 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.121 ns/day, 198.433 hours/ns, 1.400 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 713.34     | 713.34     | 713.34     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16055    | 0.16055    | 0.16055    |   0.0 |  0.02
Output  | 0.00028311 | 0.00028311 | 0.00028311 |   0.0 |  0.00
Modify  | 0.75831    | 0.75831    | 0.75831    |   0.0 |  0.11
Other   |            | 0.1009     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5973 ave        5973 max        5973 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538608 ave      538608 max      538608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538608
Ave neighs/atom = 134.652
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.784765133018, Press = 32.5891517235512
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13110.71      -13110.71      -13272.018     -13272.018      312.06199      312.06199      67583.018      67583.018      806.36198      806.36198    
      7000  -13115.108     -13115.108     -13274.115     -13274.115      307.60896      307.60896      67502.501      67502.501      1599.1581      1599.1581    
Loop time of 717.055 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.120 ns/day, 199.182 hours/ns, 1.395 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 716.02     | 716.02     | 716.02     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16259    | 0.16259    | 0.16259    |   0.0 |  0.02
Output  | 0.00024469 | 0.00024469 | 0.00024469 |   0.0 |  0.00
Modify  | 0.76855    | 0.76855    | 0.76855    |   0.0 |  0.11
Other   |            | 0.1011     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5984 ave        5984 max        5984 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538736 ave      538736 max      538736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538736
Ave neighs/atom = 134.684
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.113222185293, Press = -2.03564570240985
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13115.108     -13115.108     -13274.115     -13274.115      307.60896      307.60896      67502.501      67502.501      1599.1581      1599.1581    
      8000  -13108.435     -13108.435     -13272.591     -13272.591      317.57104      317.57104      67671.509      67671.509     -271.319       -271.319      
Loop time of 748.608 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.115 ns/day, 207.947 hours/ns, 1.336 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 747.52     | 747.52     | 747.52     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16834    | 0.16834    | 0.16834    |   0.0 |  0.02
Output  | 0.00018828 | 0.00018828 | 0.00018828 |   0.0 |  0.00
Modify  | 0.81006    | 0.81006    | 0.81006    |   0.0 |  0.11
Other   |            | 0.1062     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6020 ave        6020 max        6020 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538804 ave      538804 max      538804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538804
Ave neighs/atom = 134.701
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.15998070528, Press = -8.24404281954419
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13108.435     -13108.435     -13272.591     -13272.591      317.57104      317.57104      67671.509      67671.509     -271.319       -271.319      
      9000  -13115.473     -13115.473     -13275.798     -13275.798      310.15834      310.15834      67680.297      67680.297     -577.08063     -577.08063    
Loop time of 727.393 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.119 ns/day, 202.054 hours/ns, 1.375 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 726.34     | 726.34     | 726.34     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16297    | 0.16297    | 0.16297    |   0.0 |  0.02
Output  | 0.00018705 | 0.00018705 | 0.00018705 |   0.0 |  0.00
Modify  | 0.78691    | 0.78691    | 0.78691    |   0.0 |  0.11
Other   |            | 0.1038     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5940 ave        5940 max        5940 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538592 ave      538592 max      538592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538592
Ave neighs/atom = 134.648
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.912363969312, Press = 1.88068655804717
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13115.473     -13115.473     -13275.798     -13275.798      310.15834      310.15834      67680.297      67680.297     -577.08063     -577.08063    
     10000  -13109.027     -13109.027     -13269.398     -13269.398      310.24852      310.24852      67670.875      67670.875     -65.677523     -65.677523    
Loop time of 759.383 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.114 ns/day, 210.940 hours/ns, 1.317 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 758.27     | 758.27     | 758.27     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16992    | 0.16992    | 0.16992    |   0.0 |  0.02
Output  | 0.00024491 | 0.00024491 | 0.00024491 |   0.0 |  0.00
Modify  | 0.83429    | 0.83429    | 0.83429    |   0.0 |  0.11
Other   |            | 0.1083     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5978 ave        5978 max        5978 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538396 ave      538396 max      538396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538396
Ave neighs/atom = 134.599
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.16949190418, Press = 5.71236081046339
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13109.027     -13109.027     -13269.398     -13269.398      310.24852      310.24852      67670.875      67670.875     -65.677523     -65.677523    
     11000  -13111.848     -13111.848     -13272.736     -13272.736      311.24897      311.24897      67612.255      67612.255      373.40736      373.40736    
Loop time of 765.161 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.113 ns/day, 212.545 hours/ns, 1.307 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 764.04     | 764.04     | 764.04     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16985    | 0.16985    | 0.16985    |   0.0 |  0.02
Output  | 0.00019408 | 0.00019408 | 0.00019408 |   0.0 |  0.00
Modify  | 0.8364     | 0.8364     | 0.8364     |   0.0 |  0.11
Other   |            | 0.1094     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5984 ave        5984 max        5984 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538596 ave      538596 max      538596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538596
Ave neighs/atom = 134.649
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.068244231242, Press = 6.40225392105853
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13111.848     -13111.848     -13272.736     -13272.736      311.24897      311.24897      67612.255      67612.255      373.40736      373.40736    
     12000  -13117.437     -13117.437     -13279.271     -13279.271      313.07876      313.07876      67518.011      67518.011      1032.0086      1032.0086    
Loop time of 756.351 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.114 ns/day, 210.097 hours/ns, 1.322 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 755.26     | 755.26     | 755.26     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17069    | 0.17069    | 0.17069    |   0.0 |  0.02
Output  | 0.00018927 | 0.00018927 | 0.00018927 |   0.0 |  0.00
Modify  | 0.8173     | 0.8173     | 0.8173     |   0.0 |  0.11
Other   |            | 0.1057     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6002 ave        6002 max        6002 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538758 ave      538758 max      538758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538758
Ave neighs/atom = 134.6895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.952649755093, Press = 3.58142962468333
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13117.437     -13117.437     -13279.271     -13279.271      313.07876      313.07876      67518.011      67518.011      1032.0086      1032.0086    
     13000  -13108.601     -13108.601     -13274.841     -13274.841      321.60232      321.60232      67571.753      67571.753      814.12946      814.12946    
Loop time of 753.336 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.115 ns/day, 209.260 hours/ns, 1.327 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 752.24     | 752.24     | 752.24     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17155    | 0.17155    | 0.17155    |   0.0 |  0.02
Output  | 0.00026619 | 0.00026619 | 0.00026619 |   0.0 |  0.00
Modify  | 0.82138    | 0.82138    | 0.82138    |   0.0 |  0.11
Other   |            | 0.107      |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6034 ave        6034 max        6034 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538868 ave      538868 max      538868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538868
Ave neighs/atom = 134.717
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.873383630623, Press = -3.04412099299183
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13108.601     -13108.601     -13274.841     -13274.841      321.60232      321.60232      67571.753      67571.753      814.12946      814.12946    
     14000  -13113.404     -13113.404     -13272.285     -13272.285      307.36729      307.36729      67701.22       67701.22      -660.19616     -660.19616    
Loop time of 764.322 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.113 ns/day, 212.312 hours/ns, 1.308 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 763.19     | 763.19     | 763.19     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17183    | 0.17183    | 0.17183    |   0.0 |  0.02
Output  | 0.00052494 | 0.00052494 | 0.00052494 |   0.0 |  0.00
Modify  | 0.84935    | 0.84935    | 0.84935    |   0.0 |  0.11
Other   |            | 0.1094     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5956 ave        5956 max        5956 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538798 ave      538798 max      538798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538798
Ave neighs/atom = 134.6995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.797862502525, Press = -1.4100202583819
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13113.404     -13113.404     -13272.285     -13272.285      307.36729      307.36729      67701.22       67701.22      -660.19616     -660.19616    
     15000  -13116.457     -13116.457     -13275.854     -13275.854      308.36439      308.36439      67714.293      67714.293     -1028.9293     -1028.9293    
Loop time of 748.675 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.115 ns/day, 207.965 hours/ns, 1.336 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 747.59     | 747.59     | 747.59     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16711    | 0.16711    | 0.16711    |   0.0 |  0.02
Output  | 0.0002909  | 0.0002909  | 0.0002909  |   0.0 |  0.00
Modify  | 0.81108    | 0.81108    | 0.81108    |   0.0 |  0.11
Other   |            | 0.1055     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5988 ave        5988 max        5988 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538470 ave      538470 max      538470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538470
Ave neighs/atom = 134.6175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.847671188638, Press = 2.1264524620729
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13116.457     -13116.457     -13275.854     -13275.854      308.36439      308.36439      67714.293      67714.293     -1028.9293     -1028.9293    
     16000  -13111.182     -13111.182     -13274.757     -13274.757      316.44789      316.44789      67692.811      67692.811     -665.8125      -665.8125     
Loop time of 761.611 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.113 ns/day, 211.559 hours/ns, 1.313 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 760.51     | 760.51     | 760.51     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16856    | 0.16856    | 0.16856    |   0.0 |  0.02
Output  | 0.00019101 | 0.00019101 | 0.00019101 |   0.0 |  0.00
Modify  | 0.82735    | 0.82735    | 0.82735    |   0.0 |  0.11
Other   |            | 0.1088     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5947 ave        5947 max        5947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538378 ave      538378 max      538378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538378
Ave neighs/atom = 134.5945
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.718957467665, Press = 4.19712788919155
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13111.182     -13111.182     -13274.757     -13274.757      316.44789      316.44789      67692.811      67692.811     -665.8125      -665.8125     
     17000  -13112.295     -13112.295     -13274.115     -13274.115      313.05271      313.05271      67597.38       67597.38       511.00309      511.00309    
Loop time of 732.039 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.118 ns/day, 203.344 hours/ns, 1.366 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 730.97     | 730.97     | 730.97     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16587    | 0.16587    | 0.16587    |   0.0 |  0.02
Output  | 0.00018906 | 0.00018906 | 0.00018906 |   0.0 |  0.00
Modify  | 0.79342    | 0.79342    | 0.79342    |   0.0 |  0.11
Other   |            | 0.1047     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5962 ave        5962 max        5962 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538468 ave      538468 max      538468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538468
Ave neighs/atom = 134.617
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.676524574361, Press = 4.2236698654166
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13112.295     -13112.295     -13274.115     -13274.115      313.05271      313.05271      67597.38       67597.38       511.00309      511.00309    
     18000  -13112.667     -13112.667     -13274.682     -13274.682      313.42904      313.42904      67560.982      67560.982      856.65171      856.65171    
Loop time of 759.591 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.114 ns/day, 210.997 hours/ns, 1.316 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 758.47     | 758.47     | 758.47     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17327    | 0.17327    | 0.17327    |   0.0 |  0.02
Output  | 0.0001881  | 0.0001881  | 0.0001881  |   0.0 |  0.00
Modify  | 0.84254    | 0.84254    | 0.84254    |   0.0 |  0.11
Other   |            | 0.1091     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6024 ave        6024 max        6024 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538622 ave      538622 max      538622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538622
Ave neighs/atom = 134.6555
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.726041009759, Press = 1.802057650194
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13112.667     -13112.667     -13274.682     -13274.682      313.42904      313.42904      67560.982      67560.982      856.65171      856.65171    
     19000  -13115.123     -13115.123     -13275.449     -13275.449      310.16244      310.16244      67599.396      67599.396      335.80966      335.80966    
Loop time of 739.994 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.117 ns/day, 205.554 hours/ns, 1.351 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 738.92     | 738.92     | 738.92     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16434    | 0.16434    | 0.16434    |   0.0 |  0.02
Output  | 0.00019443 | 0.00019443 | 0.00019443 |   0.0 |  0.00
Modify  | 0.80631    | 0.80631    | 0.80631    |   0.0 |  0.11
Other   |            | 0.1045     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5976 ave        5976 max        5976 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538512 ave      538512 max      538512 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538512
Ave neighs/atom = 134.628
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.603236473606, Press = 0.761748958152458
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13115.123     -13115.123     -13275.449     -13275.449      310.16244      310.16244      67599.396      67599.396      335.80966      335.80966    
     20000  -13109.387     -13109.387     -13272.054     -13272.054      314.69038      314.69038      67650.981      67650.981     -5.5016072     -5.5016072    
Loop time of 694.627 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.124 ns/day, 192.952 hours/ns, 1.440 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 693.64     | 693.64     | 693.64     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15399    | 0.15399    | 0.15399    |   0.0 |  0.02
Output  | 0.00018966 | 0.00018966 | 0.00018966 |   0.0 |  0.00
Modify  | 0.7364     | 0.7364     | 0.7364     |   0.0 |  0.11
Other   |            | 0.09885    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6005 ave        6005 max        6005 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538512 ave      538512 max      538512 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538512
Ave neighs/atom = 134.628
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.662382562646, Press = 0.304167668845311
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13109.387     -13109.387     -13272.054     -13272.054      314.69038      314.69038      67650.981      67650.981     -5.5016072     -5.5016072    
     21000  -13111.892     -13111.892     -13273.527     -13273.527      312.69496      312.69496      67670.312      67670.312     -310.47852     -310.47852    
Loop time of 708.799 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.122 ns/day, 196.888 hours/ns, 1.411 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 707.79     | 707.79     | 707.79     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1564     | 0.1564     | 0.1564     |   0.0 |  0.02
Output  | 0.00018997 | 0.00018997 | 0.00018997 |   0.0 |  0.00
Modify  | 0.75453    | 0.75453    | 0.75453    |   0.0 |  0.11
Other   |            | 0.1017     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5967 ave        5967 max        5967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538612 ave      538612 max      538612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538612
Ave neighs/atom = 134.653
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.683916933835, Press = 1.00273306626261
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13111.892     -13111.892     -13273.527     -13273.527      312.69496      312.69496      67670.312      67670.312     -310.47852     -310.47852    
     22000  -13109.991     -13109.991     -13272.669     -13272.669      314.7127       314.7127       67652.552      67652.552     -15.008117     -15.008117    
Loop time of 747.172 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.116 ns/day, 207.548 hours/ns, 1.338 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 746.09     | 746.09     | 746.09     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16707    | 0.16707    | 0.16707    |   0.0 |  0.02
Output  | 0.0001957  | 0.0001957  | 0.0001957  |   0.0 |  0.00
Modify  | 0.81216    | 0.81216    | 0.81216    |   0.0 |  0.11
Other   |            | 0.1051     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5966 ave        5966 max        5966 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538468 ave      538468 max      538468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538468
Ave neighs/atom = 134.617
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.867149117679, Press = 1.82623961208378
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13109.991     -13109.991     -13272.669     -13272.669      314.7127       314.7127       67652.552      67652.552     -15.008117     -15.008117    
     23000  -13112.098     -13112.098     -13276.099     -13276.099      317.27032      317.27032      67569.265      67569.265      692.74968      692.74968    
Loop time of 745.84 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.116 ns/day, 207.178 hours/ns, 1.341 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 744.75     | 744.75     | 744.75     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16428    | 0.16428    | 0.16428    |   0.0 |  0.02
Output  | 0.00019438 | 0.00019438 | 0.00019438 |   0.0 |  0.00
Modify  | 0.81949    | 0.81949    | 0.81949    |   0.0 |  0.11
Other   |            | 0.1064     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6007 ave        6007 max        6007 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538528 ave      538528 max      538528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538528
Ave neighs/atom = 134.632
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.881054719744, Press = 2.82981071811195
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13112.098     -13112.098     -13276.099     -13276.099      317.27032      317.27032      67569.265      67569.265      692.74968      692.74968    
     24000  -13110.406     -13110.406     -13275.043     -13275.043      318.5013       318.5013       67518.184      67518.184      1390.5459      1390.5459    
Loop time of 735.287 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.118 ns/day, 204.246 hours/ns, 1.360 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 734.24     | 734.24     | 734.24     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16212    | 0.16212    | 0.16212    |   0.0 |  0.02
Output  | 0.00035097 | 0.00035097 | 0.00035097 |   0.0 |  0.00
Modify  | 0.78426    | 0.78426    | 0.78426    |   0.0 |  0.11
Other   |            | 0.1028     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5978 ave        5978 max        5978 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538690 ave      538690 max      538690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538690
Ave neighs/atom = 134.6725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.866830460665, Press = 0.537497943873981
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13110.406     -13110.406     -13275.043     -13275.043      318.5013       318.5013       67518.184      67518.184      1390.5459      1390.5459    
     25000  -13116.671     -13116.671     -13278.253     -13278.253      312.5911       312.5911       67598.515      67598.515      178.31063      178.31063    
Loop time of 748.932 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.115 ns/day, 208.037 hours/ns, 1.335 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 747.83     | 747.83     | 747.83     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16981    | 0.16981    | 0.16981    |   0.0 |  0.02
Output  | 0.00019507 | 0.00019507 | 0.00019507 |   0.0 |  0.00
Modify  | 0.82487    | 0.82487    | 0.82487    |   0.0 |  0.11
Other   |            | 0.1056     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6028 ave        6028 max        6028 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538830 ave      538830 max      538830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538830
Ave neighs/atom = 134.7075
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.849407348239, Press = -0.637748293549283
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13116.671     -13116.671     -13278.253     -13278.253      312.5911       312.5911       67598.515      67598.515      178.31063      178.31063    
     26000  -13111.337     -13111.337     -13271.093     -13271.093      309.05875      309.05875      67667.201      67667.201     -182.29721     -182.29721    
Loop time of 758.533 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.114 ns/day, 210.704 hours/ns, 1.318 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 757.43     | 757.43     | 757.43     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16643    | 0.16643    | 0.16643    |   0.0 |  0.02
Output  | 0.00019418 | 0.00019418 | 0.00019418 |   0.0 |  0.00
Modify  | 0.83354    | 0.83354    | 0.83354    |   0.0 |  0.11
Other   |            | 0.1064     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5973 ave        5973 max        5973 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538526 ave      538526 max      538526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538526
Ave neighs/atom = 134.6315
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.79656068117, Press = 0.224277160409696
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13111.337     -13111.337     -13271.093     -13271.093      309.05875      309.05875      67667.201      67667.201     -182.29721     -182.29721    
     27000  -13112.303     -13112.303     -13273.727     -13273.727      312.28467      312.28467      67670.314      67670.314     -351.18419     -351.18419    
Loop time of 710.309 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.122 ns/day, 197.308 hours/ns, 1.408 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 709.29     | 709.29     | 709.29     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15429    | 0.15429    | 0.15429    |   0.0 |  0.02
Output  | 0.0001904  | 0.0001904  | 0.0001904  |   0.0 |  0.00
Modify  | 0.76171    | 0.76171    | 0.76171    |   0.0 |  0.11
Other   |            | 0.1014     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5944 ave        5944 max        5944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538558 ave      538558 max      538558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538558
Ave neighs/atom = 134.6395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.893526487891, Press = 0.998809749851252
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13112.303     -13112.303     -13273.727     -13273.727      312.28467      312.28467      67670.314      67670.314     -351.18419     -351.18419    
     28000  -13114.537     -13114.537     -13274.787     -13274.787      310.01498      310.01498      67618.431      67618.431      158.34719      158.34719    
Loop time of 649.412 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.392 hours/ns, 1.540 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 648.51     | 648.51     | 648.51     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14214    | 0.14214    | 0.14214    |   0.0 |  0.02
Output  | 0.00019557 | 0.00019557 | 0.00019557 |   0.0 |  0.00
Modify  | 0.66661    | 0.66661    | 0.66661    |   0.0 |  0.10
Other   |            | 0.09749    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5982 ave        5982 max        5982 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538422 ave      538422 max      538422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538422
Ave neighs/atom = 134.6055
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.946734440938, Press = 1.03772096780685
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13114.537     -13114.537     -13274.787     -13274.787      310.01498      310.01498      67618.431      67618.431      158.34719      158.34719    
     29000  -13112.315     -13112.315     -13271.957     -13271.957      308.83832      308.83832      67635.442      67635.442      158.74264      158.74264    
Loop time of 648.126 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.035 hours/ns, 1.543 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 647.22     | 647.22     | 647.22     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14133    | 0.14133    | 0.14133    |   0.0 |  0.02
Output  | 0.00019442 | 0.00019442 | 0.00019442 |   0.0 |  0.00
Modify  | 0.66656    | 0.66656    | 0.66656    |   0.0 |  0.10
Other   |            | 0.09801    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5954 ave        5954 max        5954 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538668 ave      538668 max      538668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538668
Ave neighs/atom = 134.667
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.969804882475, Press = 0.784641900234973
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13112.315     -13112.315     -13271.957     -13271.957      308.83832      308.83832      67635.442      67635.442      158.74264      158.74264    
     30000  -13115.82      -13115.82      -13277.24      -13277.24       312.27937      312.27937      67606.317      67606.317      106.19917      106.19917    
Loop time of 648.887 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.246 hours/ns, 1.541 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 647.98     | 647.98     | 647.98     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14305    | 0.14305    | 0.14305    |   0.0 |  0.02
Output  | 0.00024006 | 0.00024006 | 0.00024006 |   0.0 |  0.00
Modify  | 0.66723    | 0.66723    | 0.66723    |   0.0 |  0.10
Other   |            | 0.09765    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6021 ave        6021 max        6021 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538608 ave      538608 max      538608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538608
Ave neighs/atom = 134.652
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.970241822595, Press = 1.21068590896954
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13115.82      -13115.82      -13277.24      -13277.24       312.27937      312.27937      67606.317      67606.317      106.19917      106.19917    
     31000  -13110         -13110         -13270.535     -13270.535      310.5653       310.5653       67559.179      67559.179      1184.2855      1184.2855    
Loop time of 648.72 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.200 hours/ns, 1.541 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 647.81     | 647.81     | 647.81     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14189    | 0.14189    | 0.14189    |   0.0 |  0.02
Output  | 0.00019327 | 0.00019327 | 0.00019327 |   0.0 |  0.00
Modify  | 0.66797    | 0.66797    | 0.66797    |   0.0 |  0.10
Other   |            | 0.09675    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5980 ave        5980 max        5980 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538578 ave      538578 max      538578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538578
Ave neighs/atom = 134.6445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.947258646017, Press = 0.866623788979912
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13110         -13110         -13270.535     -13270.535      310.5653       310.5653       67559.179      67559.179      1184.2855      1184.2855    
     32000  -13116.762     -13116.762     -13276.912     -13276.912      309.82063      309.82063      67578.625      67578.625      523.85547      523.85547    
Loop time of 649.387 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.385 hours/ns, 1.540 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 648.48     | 648.48     | 648.48     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14376    | 0.14376    | 0.14376    |   0.0 |  0.02
Output  | 0.00019565 | 0.00019565 | 0.00019565 |   0.0 |  0.00
Modify  | 0.66636    | 0.66636    | 0.66636    |   0.0 |  0.10
Other   |            | 0.09666    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5969 ave        5969 max        5969 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538574 ave      538574 max      538574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538574
Ave neighs/atom = 134.6435
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.89767183343, Press = -0.346526031327531
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13116.762     -13116.762     -13276.912     -13276.912      309.82063      309.82063      67578.625      67578.625      523.85547      523.85547    
     33000  -13111.278     -13111.278     -13273.59      -13273.59       314.003        314.003        67702.9        67702.9       -705.23551     -705.23551    
Loop time of 650.573 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.715 hours/ns, 1.537 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 649.66     | 649.66     | 649.66     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14244    | 0.14244    | 0.14244    |   0.0 |  0.02
Output  | 0.00023812 | 0.00023812 | 0.00023812 |   0.0 |  0.00
Modify  | 0.67035    | 0.67035    | 0.67035    |   0.0 |  0.10
Other   |            | 0.09829    |            |       |  0.02

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5990 ave        5990 max        5990 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538768 ave      538768 max      538768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538768
Ave neighs/atom = 134.692
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.862449712618, Press = -0.174474248269293
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13111.278     -13111.278     -13273.59      -13273.59       314.003        314.003        67702.9        67702.9       -705.23551     -705.23551    
     34000  -13112.908     -13112.908     -13271.303     -13271.303      306.42708      306.42708      67693.661      67693.661     -488.50706     -488.50706    
Loop time of 649.521 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.423 hours/ns, 1.540 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 648.61     | 648.61     | 648.61     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14182    | 0.14182    | 0.14182    |   0.0 |  0.02
Output  | 0.00024277 | 0.00024277 | 0.00024277 |   0.0 |  0.00
Modify  | 0.66791    | 0.66791    | 0.66791    |   0.0 |  0.10
Other   |            | 0.09642    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5970 ave        5970 max        5970 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538464 ave      538464 max      538464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538464
Ave neighs/atom = 134.616
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.83302327188, Press = 0.907766708300133
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13112.908     -13112.908     -13271.303     -13271.303      306.42708      306.42708      67693.661      67693.661     -488.50706     -488.50706    
     35000  -13114.351     -13114.351     -13275.89      -13275.89       312.50761      312.50761      67653.053      67653.053     -255.15393     -255.15393    
Loop time of 650.54 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.706 hours/ns, 1.537 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 649.63     | 649.63     | 649.63     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14334    | 0.14334    | 0.14334    |   0.0 |  0.02
Output  | 0.00019635 | 0.00019635 | 0.00019635 |   0.0 |  0.00
Modify  | 0.66944    | 0.66944    | 0.66944    |   0.0 |  0.10
Other   |            | 0.09694    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5974 ave        5974 max        5974 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538500 ave      538500 max      538500 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538500
Ave neighs/atom = 134.625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.844514395115, Press = 1.24377315719818
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13114.351     -13114.351     -13275.89      -13275.89       312.50761      312.50761      67653.053      67653.053     -255.15393     -255.15393    
     36000  -13112.952     -13112.952     -13273.331     -13273.331      310.26289      310.26289      67576.591      67576.591      856.12932      856.12932    
Loop time of 650.771 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.770 hours/ns, 1.537 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 649.86     | 649.86     | 649.86     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14074    | 0.14074    | 0.14074    |   0.0 |  0.02
Output  | 0.00019512 | 0.00019512 | 0.00019512 |   0.0 |  0.00
Modify  | 0.67107    | 0.67107    | 0.67107    |   0.0 |  0.10
Other   |            | 0.09722    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5944 ave        5944 max        5944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538582 ave      538582 max      538582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538582
Ave neighs/atom = 134.6455
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.873983388169, Press = 1.39720730059591
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13112.952     -13112.952     -13273.331     -13273.331      310.26289      310.26289      67576.591      67576.591      856.12932      856.12932    
     37000  -13113.14      -13113.14      -13275.452     -13275.452      314.00518      314.00518      67508.144      67508.144      1493.8174      1493.8174    
Loop time of 651.651 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 181.014 hours/ns, 1.535 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 650.74     | 650.74     | 650.74     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14193    | 0.14193    | 0.14193    |   0.0 |  0.02
Output  | 0.00020032 | 0.00020032 | 0.00020032 |   0.0 |  0.00
Modify  | 0.67181    | 0.67181    | 0.67181    |   0.0 |  0.10
Other   |            | 0.09648    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5949 ave        5949 max        5949 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538596 ave      538596 max      538596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538596
Ave neighs/atom = 134.649
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.895526311016, Press = 0.177031723678055
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13113.14      -13113.14      -13275.452     -13275.452      314.00518      314.00518      67508.144      67508.144      1493.8174      1493.8174    
     38000  -13113.163     -13113.163     -13277.337     -13277.337      317.60546      317.60546      67640.337      67640.337     -178.58598     -178.58598    
Loop time of 651.996 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 181.110 hours/ns, 1.534 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 651.08     | 651.08     | 651.08     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14436    | 0.14436    | 0.14436    |   0.0 |  0.02
Output  | 0.00019721 | 0.00019721 | 0.00019721 |   0.0 |  0.00
Modify  | 0.66973    | 0.66973    | 0.66973    |   0.0 |  0.10
Other   |            | 0.09777    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6003 ave        6003 max        6003 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538764 ave      538764 max      538764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538764
Ave neighs/atom = 134.691
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.95968168923, Press = -0.706088390112409
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.37 | 5.37 | 5.37 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13113.163     -13113.163     -13277.337     -13277.337      317.60546      317.60546      67640.337      67640.337     -178.58598     -178.58598    
     39000  -13114.882     -13114.882     -13275.321     -13275.321      310.38011      310.38011      67676.609      67676.609     -520.05071     -520.05071    
Loop time of 650.732 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.759 hours/ns, 1.537 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 649.82     | 649.82     | 649.82     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1424     | 0.1424     | 0.1424     |   0.0 |  0.02
Output  | 0.00019785 | 0.00019785 | 0.00019785 |   0.0 |  0.00
Modify  | 0.67186    | 0.67186    | 0.67186    |   0.0 |  0.10
Other   |            | 0.09721    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5937 ave        5937 max        5937 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       538518 ave      538518 max      538518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538518
Ave neighs/atom = 134.6295
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
jump SELF break

# Write final averaged volume to file if temperature and volume have converged; otherwise wirte a
# flag to indicate non-convergence.
variable      myStep equal step
if "${myStep} < 2000000" then "print '${V}'  file output/vol_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
67636.007755722

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0