# 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.9497474655508995*${_u_distance}
variable latticeconst_converted equal 4.9497474655508995*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.9497474655509
Lattice spacing in x,y,z = 4.9497475 4.9497475 4.9497475
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (49.497475 49.497475 49.497475)
  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 (49.497475 49.497475 49.497475)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Pb

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

kim interactions Pb
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_LeeShimBaskes_2003_Pb__MO_019208265157_001
pair_coeff * * Pb
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 207.2

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_019208265157_001#item-citation

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.236 | 4.236 | 4.236 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -7998.1292     -7998.1292     -8160          -8160           313.15         313.15         121268.81      121268.81      1425.7345      1425.7345    
      1000  -7810.8199     -7810.8199     -7982.425      -7982.425       331.98175      331.98175      124574.13      124574.13      284.04577      284.04577    
Loop time of 263.622 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.228 hours/ns, 3.793 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    | 262.63     | 262.63     | 262.63     |   0.0 | 99.62
Neigh   | 0.11707    | 0.11707    | 0.11707    |   0.0 |  0.04
Comm    | 0.1313     | 0.1313     | 0.1313     |   0.0 |  0.05
Output  | 0.00024025 | 0.00024025 | 0.00024025 |   0.0 |  0.00
Modify  | 0.64962    | 0.64962    | 0.64962    |   0.0 |  0.25
Other   |            | 0.09435    |            |       |  0.04

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

Total # of neighbors = 218876
Ave neighs/atom = 54.719
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -7810.8199     -7810.8199     -7982.425      -7982.425       331.98175      331.98175      124574.13      124574.13      284.04577      284.04577    
      2000  -7825.5097     -7825.5097     -7986.9647     -7986.9647      312.34556      312.34556      124655.27      124655.27     -253.88873     -253.88873    
Loop time of 259.51 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.333 ns/day, 72.086 hours/ns, 3.853 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    | 258.53     | 258.53     | 258.53     |   0.0 | 99.62
Neigh   | 0.11807    | 0.11807    | 0.11807    |   0.0 |  0.05
Comm    | 0.1266     | 0.1266     | 0.1266     |   0.0 |  0.05
Output  | 0.00027187 | 0.00027187 | 0.00027187 |   0.0 |  0.00
Modify  | 0.64271    | 0.64271    | 0.64271    |   0.0 |  0.25
Other   |            | 0.09394    |            |       |  0.04

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

Total # of neighbors = 218274
Ave neighs/atom = 54.5685
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -7825.5097     -7825.5097     -7986.9647     -7986.9647      312.34556      312.34556      124655.27      124655.27     -253.88873     -253.88873    
      3000  -7820.9589     -7820.9589     -7983.2474     -7983.2474      313.95802      313.95802      124679.62      124679.62     -46.804273     -46.804273    
Loop time of 260.055 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.332 ns/day, 72.237 hours/ns, 3.845 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    | 259.07     | 259.07     | 259.07     |   0.0 | 99.62
Neigh   | 0.1178     | 0.1178     | 0.1178     |   0.0 |  0.05
Comm    | 0.12625    | 0.12625    | 0.12625    |   0.0 |  0.05
Output  | 0.00023588 | 0.00023588 | 0.00023588 |   0.0 |  0.00
Modify  | 0.6438     | 0.6438     | 0.6438     |   0.0 |  0.25
Other   |            | 0.09418    |            |       |  0.04

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

Total # of neighbors = 218102
Ave neighs/atom = 54.5255
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -7820.9589     -7820.9589     -7983.2474     -7983.2474      313.95802      313.95802      124679.62      124679.62     -46.804273     -46.804273    
      4000  -7827.53       -7827.53       -7986.7672     -7986.7672      308.05505      308.05505      124578.87      124578.87      92.801544      92.801544    
Loop time of 259.904 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.332 ns/day, 72.196 hours/ns, 3.848 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    | 258.92     | 258.92     | 258.92     |   0.0 | 99.62
Neigh   | 0.11776    | 0.11776    | 0.11776    |   0.0 |  0.05
Comm    | 0.12593    | 0.12593    | 0.12593    |   0.0 |  0.05
Output  | 0.00023612 | 0.00023612 | 0.00023612 |   0.0 |  0.00
Modify  | 0.64187    | 0.64187    | 0.64187    |   0.0 |  0.25
Other   |            | 0.09383    |            |       |  0.04

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

Total # of neighbors = 218244
Ave neighs/atom = 54.561
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -7827.53       -7827.53       -7986.7672     -7986.7672      308.05505      308.05505      124578.87      124578.87      92.801544      92.801544    
      5000  -7820.5865     -7820.5865     -7986.9578     -7986.9578      321.85657      321.85657      124525.2       124525.2       328.51406      328.51406    
Loop time of 258.986 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.334 ns/day, 71.941 hours/ns, 3.861 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    | 258.01     | 258.01     | 258.01     |   0.0 | 99.62
Neigh   | 0.11763    | 0.11763    | 0.11763    |   0.0 |  0.05
Comm    | 0.12519    | 0.12519    | 0.12519    |   0.0 |  0.05
Output  | 0.00019277 | 0.00019277 | 0.00019277 |   0.0 |  0.00
Modify  | 0.64367    | 0.64367    | 0.64367    |   0.0 |  0.25
Other   |            | 0.09411    |            |       |  0.04

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

Total # of neighbors = 218144
Ave neighs/atom = 54.536
Neighbor list builds = 3
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 = 320.132398033597, Press = 135.936852028747
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -7820.5865     -7820.5865     -7986.9578     -7986.9578      321.85657      321.85657      124525.2       124525.2       328.51406      328.51406    
      6000  -7831.3694     -7831.3694     -7993.5584     -7993.5584      313.76556      313.76556      124500.58      124500.58     -50.836977     -50.836977    
Loop time of 260.444 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.332 ns/day, 72.346 hours/ns, 3.840 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    | 259.44     | 259.44     | 259.44     |   0.0 | 99.61
Neigh   | 0.11776    | 0.11776    | 0.11776    |   0.0 |  0.05
Comm    | 0.12616    | 0.12616    | 0.12616    |   0.0 |  0.05
Output  | 0.000193   | 0.000193   | 0.000193   |   0.0 |  0.00
Modify  | 0.66794    | 0.66794    | 0.66794    |   0.0 |  0.26
Other   |            | 0.09435    |            |       |  0.04

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

Total # of neighbors = 217986
Ave neighs/atom = 54.4965
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.849902736784, Press = 9.39010474020995
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -7831.3694     -7831.3694     -7993.5584     -7993.5584      313.76556      313.76556      124500.58      124500.58     -50.836977     -50.836977    
      7000  -7829.6005     -7829.6005     -7990.8683     -7990.8683      311.98337      311.98337      124573.52      124573.52     -192.29302     -192.29302    
Loop time of 259.828 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.333 ns/day, 72.174 hours/ns, 3.849 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    | 258.78     | 258.78     | 258.78     |   0.0 | 99.60
Neigh   | 0.15692    | 0.15692    | 0.15692    |   0.0 |  0.06
Comm    | 0.12624    | 0.12624    | 0.12624    |   0.0 |  0.05
Output  | 0.00019233 | 0.00019233 | 0.00019233 |   0.0 |  0.00
Modify  | 0.66732    | 0.66732    | 0.66732    |   0.0 |  0.26
Other   |            | 0.09332    |            |       |  0.04

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

Total # of neighbors = 218280
Ave neighs/atom = 54.57
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.317146123319, Press = 4.21507154968553
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -7829.6005     -7829.6005     -7990.8683     -7990.8683      311.98337      311.98337      124573.52      124573.52     -192.29302     -192.29302    
      8000  -7828.6996     -7828.6996     -7992.4525     -7992.4525      316.7911       316.7911       124538.61      124538.61     -148.06983     -148.06983    
Loop time of 259.089 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.333 ns/day, 71.969 hours/ns, 3.860 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    | 258.08     | 258.08     | 258.08     |   0.0 | 99.61
Neigh   | 0.11792    | 0.11792    | 0.11792    |   0.0 |  0.05
Comm    | 0.12536    | 0.12536    | 0.12536    |   0.0 |  0.05
Output  | 0.00023336 | 0.00023336 | 0.00023336 |   0.0 |  0.00
Modify  | 0.66805    | 0.66805    | 0.66805    |   0.0 |  0.26
Other   |            | 0.0936     |            |       |  0.04

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

Total # of neighbors = 218016
Ave neighs/atom = 54.504
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.333464153478, Press = 8.95925059905396
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -7828.6996     -7828.6996     -7992.4525     -7992.4525      316.7911       316.7911       124538.61      124538.61     -148.06983     -148.06983    
      9000  -7832.1383     -7832.1383     -7995.2945     -7995.2945      315.63684      315.63684      124608.66      124608.66     -548.05902     -548.05902    
Loop time of 259.919 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.332 ns/day, 72.200 hours/ns, 3.847 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    | 258.92     | 258.92     | 258.92     |   0.0 | 99.61
Neigh   | 0.11769    | 0.11769    | 0.11769    |   0.0 |  0.05
Comm    | 0.12604    | 0.12604    | 0.12604    |   0.0 |  0.05
Output  | 0.00023924 | 0.00023924 | 0.00023924 |   0.0 |  0.00
Modify  | 0.66607    | 0.66607    | 0.66607    |   0.0 |  0.26
Other   |            | 0.0942     |            |       |  0.04

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

Total # of neighbors = 218126
Ave neighs/atom = 54.5315
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.259900694964, Press = 3.23363497539981
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -7832.1383     -7832.1383     -7995.2945     -7995.2945      315.63684      315.63684      124608.66      124608.66     -548.05902     -548.05902    
     10000  -7826.4449     -7826.4449     -7989.8366     -7989.8366      316.09231      316.09231      124700.74      124700.74     -573.19733     -573.19733    
Loop time of 266.597 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.324 ns/day, 74.055 hours/ns, 3.751 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    | 265.56     | 265.56     | 265.56     |   0.0 | 99.61
Neigh   | 0.11855    | 0.11855    | 0.11855    |   0.0 |  0.04
Comm    | 0.12754    | 0.12754    | 0.12754    |   0.0 |  0.05
Output  | 0.00023824 | 0.00023824 | 0.00023824 |   0.0 |  0.00
Modify  | 0.69228    | 0.69228    | 0.69228    |   0.0 |  0.26
Other   |            | 0.09351    |            |       |  0.04

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

Total # of neighbors = 217990
Ave neighs/atom = 54.4975
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.318096927139, Press = 0.545886149589785
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -7826.4449     -7826.4449     -7989.8366     -7989.8366      316.09231      316.09231      124700.74      124700.74     -573.19733     -573.19733    
     11000  -7828.5363     -7828.5363     -7994.3567     -7994.3567      320.79086      320.79086      124400.08      124400.08      238.983        238.983      
Loop time of 262.377 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.329 ns/day, 72.882 hours/ns, 3.811 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    | 261.32     | 261.32     | 261.32     |   0.0 | 99.60
Neigh   | 0.15821    | 0.15821    | 0.15821    |   0.0 |  0.06
Comm    | 0.12888    | 0.12888    | 0.12888    |   0.0 |  0.05
Output  | 0.00019716 | 0.00019716 | 0.00019716 |   0.0 |  0.00
Modify  | 0.67494    | 0.67494    | 0.67494    |   0.0 |  0.26
Other   |            | 0.09141    |            |       |  0.03

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

Total # of neighbors = 217960
Ave neighs/atom = 54.49
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.665149062455, Press = -0.464291435760225
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -7828.5363     -7828.5363     -7994.3567     -7994.3567      320.79086      320.79086      124400.08      124400.08      238.983        238.983      
     12000  -7831.3215     -7831.3215     -7990.4136     -7990.4136      307.77435      307.77435      124426.53      124426.53      400.27693      400.27693    
Loop time of 262.506 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.329 ns/day, 72.918 hours/ns, 3.809 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    | 261.45     | 261.45     | 261.45     |   0.0 | 99.60
Neigh   | 0.15807    | 0.15807    | 0.15807    |   0.0 |  0.06
Comm    | 0.12736    | 0.12736    | 0.12736    |   0.0 |  0.05
Output  | 0.00019341 | 0.00019341 | 0.00019341 |   0.0 |  0.00
Modify  | 0.67475    | 0.67475    | 0.67475    |   0.0 |  0.26
Other   |            | 0.09148    |            |       |  0.03

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

Total # of neighbors = 218074
Ave neighs/atom = 54.5185
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.584465691251, Press = -0.282039363361429
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -7831.3215     -7831.3215     -7990.4136     -7990.4136      307.77435      307.77435      124426.53      124426.53      400.27693      400.27693    
     13000  -7828.1422     -7828.1422     -7988.009      -7988.009       309.27324      309.27324      124431.47      124431.47      524.61602      524.61602    
Loop time of 262.24 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.329 ns/day, 72.844 hours/ns, 3.813 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    | 261.23     | 261.23     | 261.23     |   0.0 | 99.61
Neigh   | 0.1187     | 0.1187     | 0.1187     |   0.0 |  0.05
Comm    | 0.12884    | 0.12884    | 0.12884    |   0.0 |  0.05
Output  | 0.00019525 | 0.00019525 | 0.00019525 |   0.0 |  0.00
Modify  | 0.673      | 0.673      | 0.673      |   0.0 |  0.26
Other   |            | 0.09227    |            |       |  0.04

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

Total # of neighbors = 218070
Ave neighs/atom = 54.5175
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.626689464191, Press = 2.25993061000753
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -7828.1422     -7828.1422     -7988.009      -7988.009       309.27324      309.27324      124431.47      124431.47      524.61602      524.61602    
     14000  -7826.4044     -7826.4044     -7990.9215     -7990.9215      318.26955      318.26955      124438.71      124438.71      370.81789      370.81789    
Loop time of 262.639 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.329 ns/day, 72.955 hours/ns, 3.808 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    | 261.63     | 261.63     | 261.63     |   0.0 | 99.61
Neigh   | 0.11879    | 0.11879    | 0.11879    |   0.0 |  0.05
Comm    | 0.12831    | 0.12831    | 0.12831    |   0.0 |  0.05
Output  | 0.00019563 | 0.00019563 | 0.00019563 |   0.0 |  0.00
Modify  | 0.67418    | 0.67418    | 0.67418    |   0.0 |  0.26
Other   |            | 0.0924     |            |       |  0.04

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

Total # of neighbors = 218222
Ave neighs/atom = 54.5555
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.510516589496, Press = 3.72287689263203
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -7826.4044     -7826.4044     -7990.9215     -7990.9215      318.26955      318.26955      124438.71      124438.71      370.81789      370.81789    
     15000  -7831.029      -7831.029      -7992.2317     -7992.2317      311.85753      311.85753      124517.91      124517.91     -44.349311     -44.349311    
Loop time of 279.32 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.309 ns/day, 77.589 hours/ns, 3.580 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 278.19     | 278.19     | 278.19     |   0.0 | 99.60
Neigh   | 0.16195    | 0.16195    | 0.16195    |   0.0 |  0.06
Comm    | 0.13385    | 0.13385    | 0.13385    |   0.0 |  0.05
Output  | 0.00024546 | 0.00024546 | 0.00024546 |   0.0 |  0.00
Modify  | 0.73679    | 0.73679    | 0.73679    |   0.0 |  0.26
Other   |            | 0.09804    |            |       |  0.04

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

Total # of neighbors = 218146
Ave neighs/atom = 54.5365
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.558873607015, Press = 2.70423915420425
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.229 | 4.229 | 4.229 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -7831.029      -7831.029      -7992.2317     -7992.2317      311.85753      311.85753      124517.91      124517.91     -44.349311     -44.349311    
     16000  -7831.0432     -7831.0432     -7991.6658     -7991.6658      310.73532      310.73532      124578.18      124578.18     -235.18963     -235.18963    
Loop time of 261.588 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.330 ns/day, 72.663 hours/ns, 3.823 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 260.57     | 260.57     | 260.57     |   0.0 | 99.61
Neigh   | 0.11873    | 0.11873    | 0.11873    |   0.0 |  0.05
Comm    | 0.12931    | 0.12931    | 0.12931    |   0.0 |  0.05
Output  | 0.00019458 | 0.00019458 | 0.00019458 |   0.0 |  0.00
Modify  | 0.67414    | 0.67414    | 0.67414    |   0.0 |  0.26
Other   |            | 0.09472    |            |       |  0.04

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

Total # of neighbors = 218082
Ave neighs/atom = 54.5205
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.503131978811, Press = -0.0722027766762552
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -7831.0432     -7831.0432     -7991.6658     -7991.6658      310.73532      310.73532      124578.18      124578.18     -235.18963     -235.18963    
     17000  -7831.5496     -7831.5496     -7992.8748     -7992.8748      312.09464      312.09464      124603.33      124603.33     -439.04135     -439.04135    
Loop time of 259.809 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.333 ns/day, 72.169 hours/ns, 3.849 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    | 258.81     | 258.81     | 258.81     |   0.0 | 99.61
Neigh   | 0.11793    | 0.11793    | 0.11793    |   0.0 |  0.05
Comm    | 0.12444    | 0.12444    | 0.12444    |   0.0 |  0.05
Output  | 0.00019245 | 0.00019245 | 0.00019245 |   0.0 |  0.00
Modify  | 0.66711    | 0.66711    | 0.66711    |   0.0 |  0.26
Other   |            | 0.0939     |            |       |  0.04

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

Total # of neighbors = 218082
Ave neighs/atom = 54.5205
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.441647750824, Press = 0.862796499123469
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -7831.5496     -7831.5496     -7992.8748     -7992.8748      312.09464      312.09464      124603.33      124603.33     -439.04135     -439.04135    
     18000  -7828.8652     -7828.8652     -7991.2877     -7991.2877      314.21719      314.21719      124554.9       124554.9      -124.40435     -124.40435    
Loop time of 260.873 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.331 ns/day, 72.465 hours/ns, 3.833 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    | 259.86     | 259.86     | 259.86     |   0.0 | 99.61
Neigh   | 0.11875    | 0.11875    | 0.11875    |   0.0 |  0.05
Comm    | 0.12876    | 0.12876    | 0.12876    |   0.0 |  0.05
Output  | 0.00019453 | 0.00019453 | 0.00019453 |   0.0 |  0.00
Modify  | 0.66937    | 0.66937    | 0.66937    |   0.0 |  0.26
Other   |            | 0.09264    |            |       |  0.04

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

Total # of neighbors = 218196
Ave neighs/atom = 54.549
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.43470441549, Press = 0.636839198631866
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -7828.8652     -7828.8652     -7991.2877     -7991.2877      314.21719      314.21719      124554.9       124554.9      -124.40435     -124.40435    
     19000  -7829.5591     -7829.5591     -7989.1031     -7989.1031      308.64881      308.64881      124647.15      124647.15     -348.4386      -348.4386     
Loop time of 261.557 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.330 ns/day, 72.655 hours/ns, 3.823 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    | 260.51     | 260.51     | 260.51     |   0.0 | 99.60
Neigh   | 0.15837    | 0.15837    | 0.15837    |   0.0 |  0.06
Comm    | 0.12755    | 0.12755    | 0.12755    |   0.0 |  0.05
Output  | 0.0001922  | 0.0001922  | 0.0001922  |   0.0 |  0.00
Modify  | 0.67159    | 0.67159    | 0.67159    |   0.0 |  0.26
Other   |            | 0.09208    |            |       |  0.04

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

Total # of neighbors = 218180
Ave neighs/atom = 54.545
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.393388082562, Press = -0.980248271926072
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.228 | 4.228 | 4.228 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -7829.5591     -7829.5591     -7989.1031     -7989.1031      308.64881      308.64881      124647.15      124647.15     -348.4386      -348.4386     
     20000  -7828.1421     -7828.1421     -7990.0025     -7990.0025      313.13002      313.13002      124407.44      124407.44      503.20113      503.20113    
Loop time of 262.676 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.329 ns/day, 72.966 hours/ns, 3.807 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    | 261.62     | 261.62     | 261.62     |   0.0 | 99.60
Neigh   | 0.15833    | 0.15833    | 0.15833    |   0.0 |  0.06
Comm    | 0.12975    | 0.12975    | 0.12975    |   0.0 |  0.05
Output  | 0.00019516 | 0.00019516 | 0.00019516 |   0.0 |  0.00
Modify  | 0.67323    | 0.67323    | 0.67323    |   0.0 |  0.26
Other   |            | 0.09191    |            |       |  0.03

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

Total # of neighbors = 218160
Ave neighs/atom = 54.54
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.29062268774, Press = -0.852571772716012
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.5
  ghost atom cutoff = 7.5
  binsize = 3.75, bins = 14 14 14
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.229 | 4.229 | 4.229 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -7828.1421     -7828.1421     -7990.0025     -7990.0025      313.13002      313.13002      124407.44      124407.44      503.20113      503.20113    
     21000  -7829.9161     -7829.9161     -7990.3992     -7990.3992      310.46549      310.46549      124376.7       124376.7       558.48026      558.48026    
Loop time of 261.903 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.330 ns/day, 72.751 hours/ns, 3.818 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    | 260.89     | 260.89     | 260.89     |   0.0 | 99.61
Neigh   | 0.11859    | 0.11859    | 0.11859    |   0.0 |  0.05
Comm    | 0.127      | 0.127      | 0.127      |   0.0 |  0.05
Output  | 0.00019595 | 0.00019595 | 0.00019595 |   0.0 |  0.00
Modify  | 0.67494    | 0.67494    | 0.67494    |   0.0 |  0.26
Other   |            | 0.0923     |            |       |  0.04

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0