# 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.004 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 333.15*${_u_temperature}
variable temp_converted equal 333.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_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  -13267.791     -13267.791     -13440         -13440          333.15         333.15         66430.076      66430.076      2768.9326      2768.9326    
      1000  -13080.642     -13080.642     -13262.812     -13262.812      352.41988      352.41988      67814.969      67814.969     -858.64447     -858.64447    
Loop time of 684.66 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.126 ns/day, 190.183 hours/ns, 1.461 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    | 683.68     | 683.68     | 683.68     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1542     | 0.1542     | 0.1542     |   0.0 |  0.02
Output  | 0.0002783  | 0.0002783  | 0.0002783  |   0.0 |  0.00
Modify  | 0.72735    | 0.72735    | 0.72735    |   0.0 |  0.11
Other   |            | 0.1012     |            |       |  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  -13080.642     -13080.642     -13262.812     -13262.812      352.41988      352.41988      67814.969      67814.969     -858.64447     -858.64447    
      2000  -13096.736     -13096.736     -13268.359     -13268.359      332.01647      332.01647      67726.14       67726.14      -470.76663     -470.76663    
Loop time of 756.08 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.114 ns/day, 210.022 hours/ns, 1.323 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.01     | 755.01     | 755.01     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16249    | 0.16249    | 0.16249    |   0.0 |  0.02
Output  | 0.00028445 | 0.00028445 | 0.00028445 |   0.0 |  0.00
Modify  | 0.79836    | 0.79836    | 0.79836    |   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:           5931 ave        5931 max        5931 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:       538292 ave      538292 max      538292 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538292
Ave neighs/atom = 134.573
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  -13096.736     -13096.736     -13268.359     -13268.359      332.01647      332.01647      67726.14       67726.14      -470.76663     -470.76663    
      3000  -13089.418     -13089.418     -13261.437     -13261.437      332.7833       332.7833       67709.419      67709.419      228.22234      228.22234    
Loop time of 738.082 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.117 ns/day, 205.023 hours/ns, 1.355 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    | 737.05     | 737.05     | 737.05     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16125    | 0.16125    | 0.16125    |   0.0 |  0.02
Output  | 0.00023003 | 0.00023003 | 0.00023003 |   0.0 |  0.00
Modify  | 0.76628    | 0.76628    | 0.76628    |   0.0 |  0.10
Other   |            | 0.1041     |            |       |  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:       538506 ave      538506 max      538506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538506
Ave neighs/atom = 134.6265
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  -13089.418     -13089.418     -13261.437     -13261.437      332.7833       332.7833       67709.419      67709.419      228.22234      228.22234    
      4000  -13090.813     -13090.813     -13268.533     -13268.533      343.81153      343.81153      67735.062      67735.062     -446.48225     -446.48225    
Loop time of 712.198 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.121 ns/day, 197.833 hours/ns, 1.404 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    | 711.22     | 711.22     | 711.22     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15437    | 0.15437    | 0.15437    |   0.0 |  0.02
Output  | 0.00022934 | 0.00022934 | 0.00022934 |   0.0 |  0.00
Modify  | 0.72396    | 0.72396    | 0.72396    |   0.0 |  0.10
Other   |            | 0.101      |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5968 ave        5968 max        5968 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:       538534 ave      538534 max      538534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538534
Ave neighs/atom = 134.6335
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  -13090.813     -13090.813     -13268.533     -13268.533      343.81153      343.81153      67735.062      67735.062     -446.48225     -446.48225    
      5000  -13092.35      -13092.35      -13263.052     -13263.052      330.23455      330.23455      67701.557      67701.557      201.86835      201.86835    
Loop time of 744.778 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.116 ns/day, 206.883 hours/ns, 1.343 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    | 743.73     | 743.73     | 743.73     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16206    | 0.16206    | 0.16206    |   0.0 |  0.02
Output  | 0.00023968 | 0.00023968 | 0.00023968 |   0.0 |  0.00
Modify  | 0.78059    | 0.78059    | 0.78059    |   0.0 |  0.10
Other   |            | 0.1066     |            |       |  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:       538400 ave      538400 max      538400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538400
Ave neighs/atom = 134.6
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 = 334.55615586716, Press = 54.9496699433182
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  -13092.35      -13092.35      -13263.052     -13263.052      330.23455      330.23455      67701.557      67701.557      201.86835      201.86835    
      6000  -13089.54      -13089.54      -13261.922     -13261.922      333.48468      333.48468      67724.463      67724.463      62.852161      62.852161    
Loop time of 757.962 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.114 ns/day, 210.545 hours/ns, 1.319 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    | 756.87     | 756.87     | 756.87     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16418    | 0.16418    | 0.16418    |   0.0 |  0.02
Output  | 0.00019151 | 0.00019151 | 0.00019151 |   0.0 |  0.00
Modify  | 0.81883    | 0.81883    | 0.81883    |   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:           5992 ave        5992 max        5992 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 = 332.765201716714, Press = 10.6426393116587
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  -13089.54      -13089.54      -13261.922     -13261.922      333.48468      333.48468      67724.463      67724.463      62.852161      62.852161    
      7000  -13093.699     -13093.699     -13263.203     -13263.203      327.91655      327.91655      67652.904      67652.904      739.55867      739.55867    
Loop time of 724.725 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.119 ns/day, 201.313 hours/ns, 1.380 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    | 723.68     | 723.68     | 723.68     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15905    | 0.15905    | 0.15905    |   0.0 |  0.02
Output  | 0.00022755 | 0.00022755 | 0.00022755 |   0.0 |  0.00
Modify  | 0.78625    | 0.78625    | 0.78625    |   0.0 |  0.11
Other   |            | 0.1037     |            |       |  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:       538548 ave      538548 max      538548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538548
Ave neighs/atom = 134.637
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.161967775842, Press = -4.06222474449536
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  -13093.699     -13093.699     -13263.203     -13263.203      327.91655      327.91655      67652.904      67652.904      739.55867      739.55867    
      8000  -13087.41      -13087.41      -13262.226     -13262.226      338.19327      338.19327      67842.183      67842.183     -1384.5369     -1384.5369    
Loop time of 745.345 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.116 ns/day, 207.040 hours/ns, 1.342 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    | 744.25     | 744.25     | 744.25     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16666    | 0.16666    | 0.16666    |   0.0 |  0.02
Output  | 0.00031092 | 0.00031092 | 0.00031092 |   0.0 |  0.00
Modify  | 0.8212     | 0.8212     | 0.8212     |   0.0 |  0.11
Other   |            | 0.1059     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6033 ave        6033 max        6033 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:       538646 ave      538646 max      538646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538646
Ave neighs/atom = 134.6615
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.142007054171, Press = -8.60571699160485
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  -13087.41      -13087.41      -13262.226     -13262.226      338.19327      338.19327      67842.183      67842.183     -1384.5369     -1384.5369    
      9000  -13092.243     -13092.243     -13265.729     -13265.729      335.61861      335.61861      67702.927      67702.927      49.13739       49.13739     
Loop time of 765.877 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.113 ns/day, 212.744 hours/ns, 1.306 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    | 764.75     | 764.75     | 764.75     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16541    | 0.16541    | 0.16541    |   0.0 |  0.02
Output  | 0.00019239 | 0.00019239 | 0.00019239 |   0.0 |  0.00
Modify  | 0.84888    | 0.84888    | 0.84888    |   0.0 |  0.11
Other   |            | 0.109      |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5938 ave        5938 max        5938 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:       538086 ave      538086 max      538086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538086
Ave neighs/atom = 134.5215
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.469207814741, Press = 13.1050415289861
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  -13092.243     -13092.243     -13265.729     -13265.729      335.61861      335.61861      67702.927      67702.927      49.13739       49.13739     
     10000  -13084.605     -13084.605     -13263.181     -13263.181      345.46733      345.46733      67685.346      67685.346      556.11162      556.11162    
Loop time of 704.933 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.123 ns/day, 195.815 hours/ns, 1.419 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    | 703.93     | 703.93     | 703.93     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15447    | 0.15447    | 0.15447    |   0.0 |  0.02
Output  | 0.00019991 | 0.00019991 | 0.00019991 |   0.0 |  0.00
Modify  | 0.74979    | 0.74979    | 0.74979    |   0.0 |  0.11
Other   |            | 0.1027     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6006 ave        6006 max        6006 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:       538534 ave      538534 max      538534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538534
Ave neighs/atom = 134.6335
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.703630121597, Press = -2.68087720014709
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  -13084.605     -13084.605     -13263.181     -13263.181      345.46733      345.46733      67685.346      67685.346      556.11162      556.11162    
     11000  -13091.827     -13091.827     -13264.726     -13264.726      334.48487      334.48487      67751.602      67751.602     -508.26688     -508.26688    
Loop time of 693.766 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.125 ns/day, 192.713 hours/ns, 1.441 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    | 692.78     | 692.78     | 692.78     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15534    | 0.15534    | 0.15534    |   0.0 |  0.02
Output  | 0.00028876 | 0.00028876 | 0.00028876 |   0.0 |  0.00
Modify  | 0.72907    | 0.72907    | 0.72907    |   0.0 |  0.11
Other   |            | 0.09883    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5998 ave        5998 max        5998 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:       538432 ave      538432 max      538432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538432
Ave neighs/atom = 134.608
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.799353413104, Press = -1.11401282290756
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  -13091.827     -13091.827     -13264.726     -13264.726      334.48487      334.48487      67751.602      67751.602     -508.26688     -508.26688    
     12000  -13089.018     -13089.018     -13261.248     -13261.248      333.18963      333.18963      67734.265      67734.265     -110.12433     -110.12433    
Loop time of 757.942 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.114 ns/day, 210.539 hours/ns, 1.319 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    | 756.84     | 756.84     | 756.84     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16607    | 0.16607    | 0.16607    |   0.0 |  0.02
Output  | 0.00019458 | 0.00019458 | 0.00019458 |   0.0 |  0.00
Modify  | 0.82863    | 0.82863    | 0.82863    |   0.0 |  0.11
Other   |            | 0.1065     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5975 ave        5975 max        5975 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:       538400 ave      538400 max      538400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538400
Ave neighs/atom = 134.6
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 = 334.016325542641, Press = 3.36140282852824
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  -13089.018     -13089.018     -13261.248     -13261.248      333.18963      333.18963      67734.265      67734.265     -110.12433     -110.12433    
     13000  -13096.02      -13096.02      -13265.226     -13265.226      327.3393       327.3393       67627.338      67627.338      904.15002      904.15002    
Loop time of 760.717 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.114 ns/day, 211.310 hours/ns, 1.315 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    | 759.62     | 759.62     | 759.62     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1658     | 0.1658     | 0.1658     |   0.0 |  0.02
Output  | 0.00024214 | 0.00024214 | 0.00024214 |   0.0 |  0.00
Modify  | 0.82532    | 0.82532    | 0.82532    |   0.0 |  0.11
Other   |            | 0.1066     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6001 ave        6001 max        6001 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 = 333.743934188039, Press = 0.154264990102292
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  -13096.02      -13096.02      -13265.226     -13265.226      327.3393       327.3393       67627.338      67627.338      904.15002      904.15002    
     14000  -13091.431     -13091.431     -13262.343     -13262.343      330.64023      330.64023      67796.642      67796.642     -915.75709     -915.75709    
Loop time of 753.48 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.115 ns/day, 209.300 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.4      | 752.4      | 752.4      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16306    | 0.16306    | 0.16306    |   0.0 |  0.02
Output  | 0.00050185 | 0.00050185 | 0.00050185 |   0.0 |  0.00
Modify  | 0.81281    | 0.81281    | 0.81281    |   0.0 |  0.11
Other   |            | 0.106      |            |       |  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:       538744 ave      538744 max      538744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538744
Ave neighs/atom = 134.686
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.473086429988, Press = -5.48960581319141
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  -13091.431     -13091.431     -13262.343     -13262.343      330.64023      330.64023      67796.642      67796.642     -915.75709     -915.75709    
     15000  -13094.656     -13094.656     -13266.392     -13266.392      332.23549      332.23549      67766.818      67766.818     -784.51888     -784.51888    
Loop time of 729.026 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.119 ns/day, 202.507 hours/ns, 1.372 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    | 727.97     | 727.97     | 727.97     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16091    | 0.16091    | 0.16091    |   0.0 |  0.02
Output  | 0.00030228 | 0.00030228 | 0.00030228 |   0.0 |  0.00
Modify  | 0.79538    | 0.79538    | 0.79538    |   0.0 |  0.11
Other   |            | 0.1044     |            |       |  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:       538450 ave      538450 max      538450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538450
Ave neighs/atom = 134.6125
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.353230846445, Press = 5.28148617643721
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  -13094.656     -13094.656     -13266.392     -13266.392      332.23549      332.23549      67766.818      67766.818     -784.51888     -784.51888    
     16000  -13089.699     -13089.699     -13262.452     -13262.452      334.20307      334.20307      67658.963      67658.963      735.82773      735.82773    
Loop time of 767.285 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.113 ns/day, 213.135 hours/ns, 1.303 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    | 766.17     | 766.17     | 766.17     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16423    | 0.16423    | 0.16423    |   0.0 |  0.02
Output  | 0.00019053 | 0.00019053 | 0.00019053 |   0.0 |  0.00
Modify  | 0.84387    | 0.84387    | 0.84387    |   0.0 |  0.11
Other   |            | 0.1084     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5960 ave        5960 max        5960 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:       538294 ave      538294 max      538294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538294
Ave neighs/atom = 134.5735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.203792105383, Press = 0.438999137504681
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  -13089.699     -13089.699     -13262.452     -13262.452      334.20307      334.20307      67658.963      67658.963      735.82773      735.82773    
     17000  -13097.994     -13097.994     -13268.752     -13268.752      330.34385      330.34385      67716.954      67716.954     -446.55772     -446.55772    
Loop time of 731.84 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.118 ns/day, 203.289 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.78     | 730.78     | 730.78     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16155    | 0.16155    | 0.16155    |   0.0 |  0.02
Output  | 0.0002069  | 0.0002069  | 0.0002069  |   0.0 |  0.00
Modify  | 0.79477    | 0.79477    | 0.79477    |   0.0 |  0.11
Other   |            | 0.1046     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5960 ave        5960 max        5960 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:       538644 ave      538644 max      538644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538644
Ave neighs/atom = 134.661
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.035471754876, Press = -1.07472956826628
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  -13097.994     -13097.994     -13268.752     -13268.752      330.34385      330.34385      67716.954      67716.954     -446.55772     -446.55772    
     18000  -13090.683     -13090.683     -13261.828     -13261.828      331.09185      331.09185      67770.579      67770.579     -584.50589     -584.50589    
Loop time of 754.59 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.114 ns/day, 209.608 hours/ns, 1.325 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    | 753.47     | 753.47     | 753.47     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17049    | 0.17049    | 0.17049    |   0.0 |  0.02
Output  | 0.00020026 | 0.00020026 | 0.00020026 |   0.0 |  0.00
Modify  | 0.83687    | 0.83687    | 0.83687    |   0.0 |  0.11
Other   |            | 0.1075     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5999 ave        5999 max        5999 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:       538620 ave      538620 max      538620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538620
Ave neighs/atom = 134.655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.951979145318, Press = 2.0368091948392
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   
     18000  -13090.683     -13090.683     -13261.828     -13261.828      331.09185      331.09185      67770.579      67770.579     -584.50589     -584.50589    
     19000  -13101.333     -13101.333     -13268.606     -13268.606      323.60012      323.60012      67541.79       67541.79       1632.7307      1632.7307    
Loop time of 764.002 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.113 ns/day, 212.223 hours/ns, 1.309 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    | 762.89     | 762.89     | 762.89     |   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.00021539 | 0.00021539 | 0.00021539 |   0.0 |  0.00
Modify  | 0.84158    | 0.84158    | 0.84158    |   0.0 |  0.11
Other   |            | 0.1076     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5938 ave        5938 max        5938 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:       538364 ave      538364 max      538364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538364
Ave neighs/atom = 134.591
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.783945269249, Press = 1.48732689961805
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  -13101.333     -13101.333     -13268.606     -13268.606      323.60012      323.60012      67541.79       67541.79       1632.7307      1632.7307    
     20000  -13090.059     -13090.059     -13262.077     -13262.077      332.78011      332.78011      67781.678      67781.678     -703.44135     -703.44135    
Loop time of 690.972 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.125 ns/day, 191.937 hours/ns, 1.447 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    | 689.98     | 689.98     | 689.98     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15849    | 0.15849    | 0.15849    |   0.0 |  0.02
Output  | 0.00023878 | 0.00023878 | 0.00023878 |   0.0 |  0.00
Modify  | 0.73584    | 0.73584    | 0.73584    |   0.0 |  0.11
Other   |            | 0.09772    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6027 ave        6027 max        6027 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:       538738 ave      538738 max      538738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538738
Ave neighs/atom = 134.6845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.790269942766, Press = -4.23534896014283
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  -13090.059     -13090.059     -13262.077     -13262.077      332.78011      332.78011      67781.678      67781.678     -703.44135     -703.44135    
     21000  -13085.387     -13085.387     -13259.539     -13259.539      336.9089       336.9089       67787.131      67787.131     -512.07438     -512.07438    
Loop time of 661.927 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.131 ns/day, 183.869 hours/ns, 1.511 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    | 660.99     | 660.99     | 660.99     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15514    | 0.15514    | 0.15514    |   0.0 |  0.02
Output  | 0.00020157 | 0.00020157 | 0.00020157 |   0.0 |  0.00
Modify  | 0.68708    | 0.68708    | 0.68708    |   0.0 |  0.10
Other   |            | 0.09318    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5968 ave        5968 max        5968 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:       538294 ave      538294 max      538294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538294
Ave neighs/atom = 134.5735
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.823891244713, Press = 2.30714600456496
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  -13085.387     -13085.387     -13259.539     -13259.539      336.9089       336.9089       67787.131      67787.131     -512.07438     -512.07438    
     22000  -13091.181     -13091.181     -13264.787     -13264.787      335.85314      335.85314      67665.233      67665.233      552.60296      552.60296    
Loop time of 724.347 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.119 ns/day, 201.207 hours/ns, 1.381 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    | 723.31     | 723.31     | 723.31     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16003    | 0.16003    | 0.16003    |   0.0 |  0.02
Output  | 0.00019211 | 0.00019211 | 0.00019211 |   0.0 |  0.00
Modify  | 0.77233    | 0.77233    | 0.77233    |   0.0 |  0.11
Other   |            | 0.1007     |            |       |  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:       538256 ave      538256 max      538256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538256
Ave neighs/atom = 134.564
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.978797073736, Press = 0.449683585465125
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  -13091.181     -13091.181     -13264.787     -13264.787      335.85314      335.85314      67665.233      67665.233      552.60296      552.60296    
     23000  -13089.962     -13089.962     -13260.51      -13260.51       329.9365       329.9365       67727.81       67727.81       50.792142      50.792142    
Loop time of 672.292 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.129 ns/day, 186.748 hours/ns, 1.487 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    | 671.32     | 671.32     | 671.32     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1664     | 0.1664     | 0.1664     |   0.0 |  0.02
Output  | 0.00021447 | 0.00021447 | 0.00021447 |   0.0 |  0.00
Modify  | 0.70857    | 0.70857    | 0.70857    |   0.0 |  0.11
Other   |            | 0.0933     |            |       |  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:       538416 ave      538416 max      538416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538416
Ave neighs/atom = 134.604
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.970062636523, Press = -0.391361436328988
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  -13089.962     -13089.962     -13260.51      -13260.51       329.9365       329.9365       67727.81       67727.81       50.792142      50.792142    
     24000  -13089.02      -13089.02      -13259.893     -13259.893      330.56559      330.56559      67785.101      67785.101     -540.65644     -540.65644    
Loop time of 719.409 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.120 ns/day, 199.836 hours/ns, 1.390 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    | 718.38     | 718.38     | 718.38     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1602     | 0.1602     | 0.1602     |   0.0 |  0.02
Output  | 0.00018977 | 0.00018977 | 0.00018977 |   0.0 |  0.00
Modify  | 0.77308    | 0.77308    | 0.77308    |   0.0 |  0.11
Other   |            | 0.1005     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5959 ave        5959 max        5959 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:       538614 ave      538614 max      538614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538614
Ave neighs/atom = 134.6535
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.98830277563, Press = 1.098738671984
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  -13089.02      -13089.02      -13259.893     -13259.893      330.56559      330.56559      67785.101      67785.101     -540.65644     -540.65644    
     25000  -13088.655     -13088.655     -13264.017     -13264.017      339.24926      339.24926      67567.965      67567.965      1714.7704      1714.7704    
Loop time of 698.244 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.124 ns/day, 193.957 hours/ns, 1.432 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    | 697.25     | 697.25     | 697.25     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15684    | 0.15684    | 0.15684    |   0.0 |  0.02
Output  | 0.00019218 | 0.00019218 | 0.00019218 |   0.0 |  0.00
Modify  | 0.73966    | 0.73966    | 0.73966    |   0.0 |  0.11
Other   |            | 0.09996    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5994 ave        5994 max        5994 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:       538356 ave      538356 max      538356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538356
Ave neighs/atom = 134.589
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.925325792531, Press = 1.63734661982986
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  -13088.655     -13088.655     -13264.017     -13264.017      339.24926      339.24926      67567.965      67567.965      1714.7704      1714.7704    
     26000  -13095.79      -13095.79      -13263.624     -13263.624      324.68669      324.68669      67710.002      67710.002     -10.639822     -10.639822    
Loop time of 745.856 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.116 ns/day, 207.182 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.76     | 744.76     | 744.76     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16671    | 0.16671    | 0.16671    |   0.0 |  0.02
Output  | 0.00019204 | 0.00019204 | 0.00019204 |   0.0 |  0.00
Modify  | 0.82148    | 0.82148    | 0.82148    |   0.0 |  0.11
Other   |            | 0.1054     |            |       |  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:       538750 ave      538750 max      538750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538750
Ave neighs/atom = 134.6875
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.90432159769, Press = -1.29187752041943
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  -13095.79      -13095.79      -13263.624     -13263.624      324.68669      324.68669      67710.002      67710.002     -10.639822     -10.639822    
     27000  -13091.132     -13091.132     -13264.725     -13264.725      335.82664      335.82664      67774.37       67774.37      -790.11601     -790.11601    
Loop time of 720.028 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.120 ns/day, 200.008 hours/ns, 1.389 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    | 718.99     | 718.99     | 718.99     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15824    | 0.15824    | 0.15824    |   0.0 |  0.02
Output  | 0.00019197 | 0.00019197 | 0.00019197 |   0.0 |  0.00
Modify  | 0.77377    | 0.77377    | 0.77377    |   0.0 |  0.11
Other   |            | 0.103      |            |       |  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:       538538 ave      538538 max      538538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538538
Ave neighs/atom = 134.6345
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.89794775484, Press = 1.2863356644285
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  -13091.132     -13091.132     -13264.725     -13264.725      335.82664      335.82664      67774.37       67774.37      -790.11601     -790.11601    
     28000  -13092.038     -13092.038     -13261.53      -13261.53       327.89447      327.89447      67618.099      67618.099      1242.3368      1242.3368    
Loop time of 650.581 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.717 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.67     | 649.67     | 649.67     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14526    | 0.14526    | 0.14526    |   0.0 |  0.02
Output  | 0.00019361 | 0.00019361 | 0.00019361 |   0.0 |  0.00
Modify  | 0.66841    | 0.66841    | 0.66841    |   0.0 |  0.10
Other   |            | 0.09683    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5996 ave        5996 max        5996 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:       538330 ave      538330 max      538330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538330
Ave neighs/atom = 134.5825
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.952481345693, Press = 0.885702407023746
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  -13092.038     -13092.038     -13261.53      -13261.53       327.89447      327.89447      67618.099      67618.099      1242.3368      1242.3368    
     29000  -13087.731     -13087.731     -13260.956     -13260.956      335.1142       335.1142       67759.235      67759.235     -337.08936     -337.08936    
Loop time of 650.649 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.736 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.74     | 649.74     | 649.74     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14404    | 0.14404    | 0.14404    |   0.0 |  0.02
Output  | 0.00019295 | 0.00019295 | 0.00019295 |   0.0 |  0.00
Modify  | 0.67081    | 0.67081    | 0.67081    |   0.0 |  0.10
Other   |            | 0.09615    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5958 ave        5958 max        5958 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:       538742 ave      538742 max      538742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538742
Ave neighs/atom = 134.6855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.016681532032, Press = -0.960101594333967
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  -13087.731     -13087.731     -13260.956     -13260.956      335.1142       335.1142       67759.235      67759.235     -337.08936     -337.08936    
     30000  -13095.431     -13095.431     -13265.572     -13265.572      329.1488       329.1488       67758.906      67758.906     -669.98093     -669.98093    
Loop time of 650.491 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.692 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.58     | 649.58     | 649.58     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14569    | 0.14569    | 0.14569    |   0.0 |  0.02
Output  | 0.00024152 | 0.00024152 | 0.00024152 |   0.0 |  0.00
Modify  | 0.67105    | 0.67105    | 0.67105    |   0.0 |  0.10
Other   |            | 0.09659    |            |       |  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:       538358 ave      538358 max      538358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538358
Ave neighs/atom = 134.5895
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.022564623747, Press = 1.21618282949116
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  -13095.431     -13095.431     -13265.572     -13265.572      329.1488       329.1488       67758.906      67758.906     -669.98093     -669.98093    
     31000  -13092.856     -13092.856     -13265.123     -13265.123      333.26248      333.26248      67667.563      67667.563      456.85849      456.85849    
Loop time of 650.626 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.729 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.71     | 649.71     | 649.71     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14421    | 0.14421    | 0.14421    |   0.0 |  0.02
Output  | 0.00024561 | 0.00024561 | 0.00024561 |   0.0 |  0.00
Modify  | 0.67129    | 0.67129    | 0.67129    |   0.0 |  0.10
Other   |            | 0.09591    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5975 ave        5975 max        5975 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:       538344 ave      538344 max      538344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538344
Ave neighs/atom = 134.586
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.022610945403, Press = 0.766854184633534
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  -13092.856     -13092.856     -13265.123     -13265.123      333.26248      333.26248      67667.563      67667.563      456.85849      456.85849    
     32000  -13090.403     -13090.403     -13264.568     -13264.568      336.93487      336.93487      67698.695      67698.695      200.36008      200.36008    
Loop time of 650.862 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.795 hours/ns, 1.536 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.95     | 649.95     | 649.95     |   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.00019746 | 0.00019746 | 0.00019746 |   0.0 |  0.00
Modify  | 0.67125    | 0.67125    | 0.67125    |   0.0 |  0.10
Other   |            | 0.09559    |            |       |  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:       538534 ave      538534 max      538534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538534
Ave neighs/atom = 134.6335
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.945802713465, Press = -0.195527006736802
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  -13090.403     -13090.403     -13264.568     -13264.568      336.93487      336.93487      67698.695      67698.695      200.36008      200.36008    
     33000  -13090.465     -13090.465     -13263.192     -13263.192      334.15294      334.15294      67781.044      67781.044     -680.67926     -680.67926    
Loop time of 649.35 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.375 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.44     | 648.44     | 648.44     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14444    | 0.14444    | 0.14444    |   0.0 |  0.02
Output  | 0.00019554 | 0.00019554 | 0.00019554 |   0.0 |  0.00
Modify  | 0.66784    | 0.66784    | 0.66784    |   0.0 |  0.10
Other   |            | 0.09634    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5995 ave        5995 max        5995 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:       538426 ave      538426 max      538426 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538426
Ave neighs/atom = 134.6065
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.919028500769, Press = 0.0330822635577376
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   
     33000  -13090.465     -13090.465     -13263.192     -13263.192      334.15294      334.15294      67781.044      67781.044     -680.67926     -680.67926    
     34000  -13091.409     -13091.409     -13263.874     -13263.874      333.64368      333.64368      67693.393      67693.393      218.96696      218.96696    
Loop time of 649.137 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.316 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    | 648.23     | 648.23     | 648.23     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14295    | 0.14295    | 0.14295    |   0.0 |  0.02
Output  | 0.00019478 | 0.00019478 | 0.00019478 |   0.0 |  0.00
Modify  | 0.66767    | 0.66767    | 0.66767    |   0.0 |  0.10
Other   |            | 0.09584    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5933 ave        5933 max        5933 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:       538404 ave      538404 max      538404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538404
Ave neighs/atom = 134.601
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.876406846945, Press = 1.75301032379289
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  -13091.409     -13091.409     -13263.874     -13263.874      333.64368      333.64368      67693.393      67693.393      218.96696      218.96696    
     35000  -13086.128     -13086.128     -13260.607     -13260.607      337.54021      337.54021      67616.914      67616.914      1453.3847      1453.3847    
Loop time of 648.654 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.182 hours/ns, 1.542 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.74     | 647.74     | 647.74     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14474    | 0.14474    | 0.14474    |   0.0 |  0.02
Output  | 0.00019308 | 0.00019308 | 0.00019308 |   0.0 |  0.00
Modify  | 0.66804    | 0.66804    | 0.66804    |   0.0 |  0.10
Other   |            | 0.09647    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           6035 ave        6035 max        6035 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:       538548 ave      538548 max      538548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538548
Ave neighs/atom = 134.637
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.928404807912, Press = -1.22831413480133
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  -13086.128     -13086.128     -13260.607     -13260.607      337.54021      337.54021      67616.914      67616.914      1453.3847      1453.3847    
     36000  -13088.885     -13088.885     -13260.606     -13260.606      332.20513      332.20513      67795.209      67795.209     -724.06567     -724.06567    
Loop time of 649.806 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.133 ns/day, 180.502 hours/ns, 1.539 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.9      | 648.9      | 648.9      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1455     | 0.1455     | 0.1455     |   0.0 |  0.02
Output  | 0.00019504 | 0.00019504 | 0.00019504 |   0.0 |  0.00
Modify  | 0.66622    | 0.66622    | 0.66622    |   0.0 |  0.10
Other   |            | 0.09611    |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5995 ave        5995 max        5995 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:       538702 ave      538702 max      538702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0