# 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.003 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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.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  -13298.806     -13298.806     -13440         -13440          273.15         273.15         66430.076      66430.076      2270.253       2270.253     
      1000  -13146.726     -13146.726     -13295.514     -13295.514      287.84042      287.84042      67449.119      67449.119      569.83614      569.83614    
Loop time of 698.674 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.124 ns/day, 194.076 hours/ns, 1.431 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.67     | 697.67     | 697.67     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15713    | 0.15713    | 0.15713    |   0.0 |  0.02
Output  | 0.00028107 | 0.00028107 | 0.00028107 |   0.0 |  0.00
Modify  | 0.74644    | 0.74644    | 0.74644    |   0.0 |  0.11
Other   |            | 0.1011     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           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  -13146.726     -13146.726     -13295.514     -13295.514      287.84042      287.84042      67449.119      67449.119      569.83614      569.83614    
      2000  -13158.896     -13158.896     -13301.175     -13301.175      275.24709      275.24709      67483.611      67483.611     -327.17956     -327.17956    
Loop time of 757.531 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.114 ns/day, 210.425 hours/ns, 1.320 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.46     | 756.46     | 756.46     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16397    | 0.16397    | 0.16397    |   0.0 |  0.02
Output  | 0.00022996 | 0.00022996 | 0.00022996 |   0.0 |  0.00
Modify  | 0.80545    | 0.80545    | 0.80545    |   0.0 |  0.11
Other   |            | 0.1055     |            |       |  0.01

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

Total # of neighbors = 538698
Ave neighs/atom = 134.6745
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  -13158.896     -13158.896     -13301.175     -13301.175      275.24709      275.24709      67483.611      67483.611     -327.17956     -327.17956    
      3000  -13154.363     -13154.363     -13292.775     -13292.775      267.76796      267.76796      67492.682      67492.682     -15.141906     -15.141906    
Loop time of 730.608 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.118 ns/day, 202.947 hours/ns, 1.369 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    | 729.57     | 729.57     | 729.57     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16253    | 0.16253    | 0.16253    |   0.0 |  0.02
Output  | 0.00028222 | 0.00028222 | 0.00028222 |   0.0 |  0.00
Modify  | 0.77139    | 0.77139    | 0.77139    |   0.0 |  0.11
Other   |            | 0.1034     |            |       |  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:       538590 ave      538590 max      538590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538590
Ave neighs/atom = 134.6475
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   
      3000  -13154.363     -13154.363     -13292.775     -13292.775      267.76796      267.76796      67492.682      67492.682     -15.141906     -15.141906    
      4000  -13153.761     -13153.761     -13297.792     -13297.792      278.63636      278.63636      67499.391      67499.391     -247.58848     -247.58848    
Loop time of 706.482 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.122 ns/day, 196.245 hours/ns, 1.415 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    | 705.5      | 705.5      | 705.5      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15766    | 0.15766    | 0.15766    |   0.0 |  0.02
Output  | 0.00023019 | 0.00023019 | 0.00023019 |   0.0 |  0.00
Modify  | 0.72344    | 0.72344    | 0.72344    |   0.0 |  0.10
Other   |            | 0.09955    |            |       |  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:       538774 ave      538774 max      538774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538774
Ave neighs/atom = 134.6935
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  -13153.761     -13153.761     -13297.792     -13297.792      278.63636      278.63636      67499.391      67499.391     -247.58848     -247.58848    
      5000  -13156.831     -13156.831     -13297.108     -13297.108      271.37501      271.37501      67430.409      67430.409      505.25171      505.25171    
Loop time of 721.517 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.120 ns/day, 200.421 hours/ns, 1.386 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    | 720.49     | 720.49     | 720.49     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1627     | 0.1627     | 0.1627     |   0.0 |  0.02
Output  | 0.00025997 | 0.00025997 | 0.00025997 |   0.0 |  0.00
Modify  | 0.76382    | 0.76382    | 0.76382    |   0.0 |  0.11
Other   |            | 0.1026     |            |       |  0.01

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

Total # of neighbors = 538656
Ave neighs/atom = 134.664
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 = 272.906781985217, Press = -185.607788134401
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  -13156.831     -13156.831     -13297.108     -13297.108      271.37501      271.37501      67430.409      67430.409      505.25171      505.25171    
      6000  -13153.034     -13153.034     -13295.36      -13295.36       275.34095      275.34095      67406          67406          925.85311      925.85311    
Loop time of 755.972 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.114 ns/day, 209.992 hours/ns, 1.323 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    | 754.87     | 754.87     | 754.87     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16647    | 0.16647    | 0.16647    |   0.0 |  0.02
Output  | 0.00019073 | 0.00019073 | 0.00019073 |   0.0 |  0.00
Modify  | 0.83397    | 0.83397    | 0.83397    |   0.0 |  0.11
Other   |            | 0.1058     |            |       |  0.01

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

Total # of neighbors = 538748
Ave neighs/atom = 134.687
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 = 272.84816501269, Press = -0.687367877700645
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  -13153.034     -13153.034     -13295.36      -13295.36       275.34095      275.34095      67406          67406          925.85311      925.85311    
      7000  -13157.609     -13157.609     -13299.644     -13299.644      274.77727      274.77727      67420.613      67420.613      436.13941      436.13941    
Loop time of 732.934 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.118 ns/day, 203.593 hours/ns, 1.364 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    | 731.86     | 731.86     | 731.86     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1642     | 0.1642     | 0.1642     |   0.0 |  0.02
Output  | 0.00019004 | 0.00019004 | 0.00019004 |   0.0 |  0.00
Modify  | 0.80228    | 0.80228    | 0.80228    |   0.0 |  0.11
Other   |            | 0.1024     |            |       |  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:       538856 ave      538856 max      538856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538856
Ave neighs/atom = 134.714
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 = 273.132092116783, Press = 18.2248415019482
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  -13157.609     -13157.609     -13299.644     -13299.644      274.77727      274.77727      67420.613      67420.613      436.13941      436.13941    
      8000  -13152.36      -13152.36      -13293.041     -13293.041      272.15837      272.15837      67556.455      67556.455     -677.50905     -677.50905    
Loop time of 738.115 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.117 ns/day, 205.032 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.04     | 737.04     | 737.04     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16528    | 0.16528    | 0.16528    |   0.0 |  0.02
Output  | 0.00023718 | 0.00023718 | 0.00023718 |   0.0 |  0.00
Modify  | 0.80624    | 0.80624    | 0.80624    |   0.0 |  0.11
Other   |            | 0.1018     |            |       |  0.01

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

Total # of neighbors = 538694
Ave neighs/atom = 134.6735
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 = 273.175675740725, Press = 4.83006446816424
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  -13152.36      -13152.36      -13293.041     -13293.041      272.15837      272.15837      67556.455      67556.455     -677.50905     -677.50905    
      9000  -13156.129     -13156.129     -13297.235     -13297.235      272.98035      272.98035      67540.353      67540.353     -770.73874     -770.73874    
Loop time of 722.047 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.120 ns/day, 200.569 hours/ns, 1.385 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    | 721        | 721        | 721        |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16123    | 0.16123    | 0.16123    |   0.0 |  0.02
Output  | 0.00019076 | 0.00019076 | 0.00019076 |   0.0 |  0.00
Modify  | 0.78176    | 0.78176    | 0.78176    |   0.0 |  0.11
Other   |            | 0.1011     |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5922 ave        5922 max        5922 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 = 273.282273113086, Press = -3.45646442926251
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  -13156.129     -13156.129     -13297.235     -13297.235      272.98035      272.98035      67540.353      67540.353     -770.73874     -770.73874    
     10000  -13150.93      -13150.93      -13295.896     -13295.896      280.44697      280.44697      67510.615      67510.615     -335.58723     -335.58723    
Loop time of 743.92 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.116 ns/day, 206.645 hours/ns, 1.344 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    | 742.85     | 742.85     | 742.85     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16298    | 0.16298    | 0.16298    |   0.0 |  0.02
Output  | 0.00026159 | 0.00026159 | 0.00026159 |   0.0 |  0.00
Modify  | 0.80806    | 0.80806    | 0.80806    |   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:           5971 ave        5971 max        5971 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:       538522 ave      538522 max      538522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 538522
Ave neighs/atom = 134.6305
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 = 273.564117103168, Press = -4.73862189818654
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  -13150.93      -13150.93      -13295.896     -13295.896      280.44697      280.44697      67510.615      67510.615     -335.58723     -335.58723    
     11000  -13155.28      -13155.28      -13296.796     -13296.796      273.77318      273.77318      67460.704      67460.704      164.76229      164.76229    
Loop time of 765.131 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.113 ns/day, 212.537 hours/ns, 1.307 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.01     | 764.01     | 764.01     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16913    | 0.16913    | 0.16913    |   0.0 |  0.02
Output  | 0.00026518 | 0.00026518 | 0.00026518 |   0.0 |  0.00
Modify  | 0.84428    | 0.84428    | 0.84428    |   0.0 |  0.11
Other   |            | 0.1058     |            |       |  0.01

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

Total # of neighbors = 538700
Ave neighs/atom = 134.675
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 = 273.576933703461, Press = -3.53107826098471
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   
     11000  -13155.28      -13155.28      -13296.796     -13296.796      273.77318      273.77318      67460.704      67460.704      164.76229      164.76229    
     12000  -13158.598     -13158.598     -13296.43      -13296.43       266.64543      266.64543      67404.918      67404.918      820.97025      820.97025    
Loop time of 735.886 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.117 ns/day, 204.413 hours/ns, 1.359 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    | 734.81     | 734.81     | 734.81     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16406    | 0.16406    | 0.16406    |   0.0 |  0.02
Output  | 0.00019246 | 0.00019246 | 0.00019246 |   0.0 |  0.00
Modify  | 0.80581    | 0.80581    | 0.80581    |   0.0 |  0.11
Other   |            | 0.1035     |            |       |  0.01

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

Total # of neighbors = 538688
Ave neighs/atom = 134.672
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 = 273.484584184131, Press = 0.328854566657134
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  -13158.598     -13158.598     -13296.43      -13296.43       266.64543      266.64543      67404.918      67404.918      820.97025      820.97025    
     13000  -13154.443     -13154.443     -13296.493     -13296.493      274.80456      274.80456      67461.358      67461.358      198.83134      198.83134    
Loop time of 752.006 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.115 ns/day, 208.891 hours/ns, 1.330 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    | 750.9      | 750.9      | 750.9      |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16938    | 0.16938    | 0.16938    |   0.0 |  0.02
Output  | 0.0001946  | 0.0001946  | 0.0001946  |   0.0 |  0.00
Modify  | 0.83564    | 0.83564    | 0.83564    |   0.0 |  0.11
Other   |            | 0.105      |            |       |  0.01

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

Total # of neighbors = 538938
Ave neighs/atom = 134.7345
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 = 273.285363217096, Press = 3.77331920374718
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   
     13000  -13154.443     -13154.443     -13296.493     -13296.493      274.80456      274.80456      67461.358      67461.358      198.83134      198.83134    
     14000  -13164.157     -13164.157     -13301.896     -13301.896      266.46645      266.46645      67515.344      67515.344     -847.8685      -847.8685     
Loop time of 749.535 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.115 ns/day, 208.204 hours/ns, 1.334 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    | 748.44     | 748.44     | 748.44     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16578    | 0.16578    | 0.16578    |   0.0 |  0.02
Output  | 0.00047402 | 0.00047402 | 0.00047402 |   0.0 |  0.00
Modify  | 0.82226    | 0.82226    | 0.82226    |   0.0 |  0.11
Other   |            | 0.1039     |            |       |  0.01

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

Total # of neighbors = 538692
Ave neighs/atom = 134.673
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 = 273.102494092626, Press = 1.04335846148589
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  -13164.157     -13164.157     -13301.896     -13301.896      266.46645      266.46645      67515.344      67515.344     -847.8685      -847.8685     
     15000  -13152.261     -13152.261     -13295.813     -13295.813      277.71195      277.71195      67565.125      67565.125     -969.77883     -969.77883    
Loop time of 720.302 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.120 ns/day, 200.084 hours/ns, 1.388 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    | 719.26     | 719.26     | 719.26     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16369    | 0.16369    | 0.16369    |   0.0 |  0.02
Output  | 0.00023394 | 0.00023394 | 0.00023394 |   0.0 |  0.00
Modify  | 0.77794    | 0.77794    | 0.77794    |   0.0 |  0.11
Other   |            | 0.1        |            |       |  0.01

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5967 ave        5967 max        5967 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       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 = 272.988089622008, Press = -2.79735027276642
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  -13152.261     -13152.261     -13295.813     -13295.813      277.71195      277.71195      67565.125      67565.125     -969.77883     -969.77883    
     16000  -13155.288     -13155.288     -13294.697     -13294.697      269.69564      269.69564      67460.921      67460.921      291.88956      291.88956    
Loop time of 729.957 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.118 ns/day, 202.766 hours/ns, 1.370 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    | 728.91     | 728.91     | 728.91     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16097    | 0.16097    | 0.16097    |   0.0 |  0.02
Output  | 0.00019159 | 0.00019159 | 0.00019159 |   0.0 |  0.00
Modify  | 0.78549    | 0.78549    | 0.78549    |   0.0 |  0.11
Other   |            | 0.1011     |            |       |  0.01

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

Total # of neighbors = 538616
Ave neighs/atom = 134.654
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 = 273.0368220591, Press = -2.02514071212069
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  -13155.288     -13155.288     -13294.697     -13294.697      269.69564      269.69564      67460.921      67460.921      291.88956      291.88956    
     17000  -13151.97      -13151.97      -13294.649     -13294.649      276.02159      276.02159      67457.156      67457.156      433.80637      433.80637    
Loop time of 732.755 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.118 ns/day, 203.543 hours/ns, 1.365 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    | 731.7      | 731.7      | 731.7      |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16234    | 0.16234    | 0.16234    |   0.0 |  0.02
Output  | 0.00024699 | 0.00024699 | 0.00024699 |   0.0 |  0.00
Modify  | 0.79122    | 0.79122    | 0.79122    |   0.0 |  0.11
Other   |            | 0.1016     |            |       |  0.01

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

Total # of neighbors = 538790
Ave neighs/atom = 134.6975
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 = 273.183064318877, Press = -1.16436808119625
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  -13151.97      -13151.97      -13294.649     -13294.649      276.02159      276.02159      67457.156      67457.156      433.80637      433.80637    
     18000  -13153.277     -13153.277     -13292.945     -13292.945      270.19855      270.19855      67462.507      67462.507      433.58169      433.58169    
Loop time of 756.304 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 755.18     | 755.18     | 755.18     |   0.0 | 99.85
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17148    | 0.17148    | 0.17148    |   0.0 |  0.02
Output  | 0.00029003 | 0.00029003 | 0.00029003 |   0.0 |  0.00
Modify  | 0.8453     | 0.8453     | 0.8453     |   0.0 |  0.11
Other   |            | 0.1062     |            |       |  0.01

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

Total # of neighbors = 538756
Ave neighs/atom = 134.689
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 = 273.139739590288, Press = 0.482089329614414
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  -13153.277     -13153.277     -13292.945     -13292.945      270.19855      270.19855      67462.507      67462.507      433.58169      433.58169    
     19000  -13159.785     -13159.785     -13298.032     -13298.032      267.44753      267.44753      67481.826      67481.826     -203.1761      -203.1761     
Loop time of 727.426 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 726.37     | 726.37     | 726.37     |   0.0 | 99.86
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16006    | 0.16006    | 0.16006    |   0.0 |  0.02
Output  | 0.00026936 | 0.00026936 | 0.00026936 |   0.0 |  0.00
Modify  | 0.78929    | 0.78929    | 0.78929    |   0.0 |  0.11
Other   |            | 0.1021     |            |       |  0.01

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0