# 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.006 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 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_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  -8018.8057     -8018.8057     -8160          -8160           273.15         273.15         121268.81      121268.81      1243.6194      1243.6194    
      1000  -7857.4259     -7857.4259     -8009.3237     -8009.3237      293.85647      293.85647      123984.96      123984.96      604.058        604.058      
Loop time of 263.262 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.128 hours/ns, 3.798 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.3      | 262.3      | 262.3      |   0.0 | 99.64
Neigh   | 0.078206   | 0.078206   | 0.078206   |   0.0 |  0.03
Comm    | 0.13862    | 0.13862    | 0.13862    |   0.0 |  0.05
Output  | 0.00024532 | 0.00024532 | 0.00024532 |   0.0 |  0.00
Modify  | 0.64785    | 0.64785    | 0.64785    |   0.0 |  0.25
Other   |            | 0.09555    |            |       |  0.04

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

Total # of neighbors = 218042
Ave neighs/atom = 54.5105
Neighbor list builds = 2
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.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   
      1000  -7857.4259     -7857.4259     -8009.3237     -8009.3237      293.85647      293.85647      123984.96      123984.96      604.058        604.058      
      2000  -7869.1069     -7869.1069     -8011.1391     -8011.1391      274.77097      274.77097      124209.28      124209.28     -300.50722     -300.50722    
Loop time of 262.783 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.329 ns/day, 72.995 hours/ns, 3.805 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.8      | 261.8      | 261.8      |   0.0 | 99.63
Neigh   | 0.1177     | 0.1177     | 0.1177     |   0.0 |  0.04
Comm    | 0.12651    | 0.12651    | 0.12651    |   0.0 |  0.05
Output  | 0.00024502 | 0.00024502 | 0.00024502 |   0.0 |  0.00
Modify  | 0.63907    | 0.63907    | 0.63907    |   0.0 |  0.24
Other   |            | 0.09433    |            |       |  0.04

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

Total # of neighbors = 218050
Ave neighs/atom = 54.5125
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  -7869.1069     -7869.1069     -8011.1391     -8011.1391      274.77097      274.77097      124209.28      124209.28     -300.50722     -300.50722    
      3000  -7863.2568     -7863.2568     -8006.4295     -8006.4295      276.97737      276.97737      124240.43      124240.43     -39.614958     -39.614958    
Loop time of 263.04 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.067 hours/ns, 3.802 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.06     | 262.06     | 262.06     |   0.0 | 99.63
Neigh   | 0.11748    | 0.11748    | 0.11748    |   0.0 |  0.04
Comm    | 0.12681    | 0.12681    | 0.12681    |   0.0 |  0.05
Output  | 0.00028309 | 0.00028309 | 0.00028309 |   0.0 |  0.00
Modify  | 0.64055    | 0.64055    | 0.64055    |   0.0 |  0.24
Other   |            | 0.0939     |            |       |  0.04

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4898 ave        4898 max        4898 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 = 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  -7863.2568     -7863.2568     -8006.4295     -8006.4295      276.97737      276.97737      124240.43      124240.43     -39.614958     -39.614958    
      4000  -7871.5052     -7871.5052     -8009.3376     -8009.3376      266.64607      266.64607      124248.68      124248.68     -312.75527     -312.75527    
Loop time of 264.497 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.471 hours/ns, 3.781 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    | 263.51     | 263.51     | 263.51     |   0.0 | 99.63
Neigh   | 0.11785    | 0.11785    | 0.11785    |   0.0 |  0.04
Comm    | 0.12726    | 0.12726    | 0.12726    |   0.0 |  0.05
Output  | 0.000277   | 0.000277   | 0.000277   |   0.0 |  0.00
Modify  | 0.64209    | 0.64209    | 0.64209    |   0.0 |  0.24
Other   |            | 0.09464    |            |       |  0.04

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

Total # of neighbors = 217934
Ave neighs/atom = 54.4835
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  -7871.5052     -7871.5052     -8009.3376     -8009.3376      266.64607      266.64607      124248.68      124248.68     -312.75527     -312.75527    
      5000  -7865.6234     -7865.6234     -8010.5206     -8010.5206      280.31354      280.31354      124155.9       124155.9       36.119182      36.119182    
Loop time of 263.539 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.328 ns/day, 73.205 hours/ns, 3.795 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.56     | 262.56     | 262.56     |   0.0 | 99.63
Neigh   | 0.11768    | 0.11768    | 0.11768    |   0.0 |  0.04
Comm    | 0.12662    | 0.12662    | 0.12662    |   0.0 |  0.05
Output  | 0.00019847 | 0.00019847 | 0.00019847 |   0.0 |  0.00
Modify  | 0.64482    | 0.64482    | 0.64482    |   0.0 |  0.24
Other   |            | 0.09415    |            |       |  0.04

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

Total # of neighbors = 217894
Ave neighs/atom = 54.4735
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 = 280.731668046225, Press = -14.3689733725352
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  -7865.6234     -7865.6234     -8010.5206     -8010.5206      280.31354      280.31354      124155.9       124155.9       36.119182      36.119182    
      6000  -7875.5915     -7875.5915     -8015.1607     -8015.1607      270.00624      270.00624      124095.85      124095.85     -109.65175     -109.65175    
Loop time of 264.868 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.326 ns/day, 73.574 hours/ns, 3.775 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    | 263.86     | 263.86     | 263.86     |   0.0 | 99.62
Neigh   | 0.11802    | 0.11802    | 0.11802    |   0.0 |  0.04
Comm    | 0.1276     | 0.1276     | 0.1276     |   0.0 |  0.05
Output  | 0.00019943 | 0.00019943 | 0.00019943 |   0.0 |  0.00
Modify  | 0.67126    | 0.67126    | 0.67126    |   0.0 |  0.25
Other   |            | 0.09449    |            |       |  0.04

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

Total # of neighbors = 217660
Ave neighs/atom = 54.415
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 = 273.788725460803, Press = -3.99514725411503
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   
      6000  -7875.5915     -7875.5915     -8015.1607     -8015.1607      270.00624      270.00624      124095.85      124095.85     -109.65175     -109.65175    
      7000  -7872.2821     -7872.2821     -8013.6428     -8013.6428      273.47201      273.47201      124051.31      124051.31      143.12655      143.12655    
Loop time of 264.27 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.408 hours/ns, 3.784 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    | 263.26     | 263.26     | 263.26     |   0.0 | 99.62
Neigh   | 0.11772    | 0.11772    | 0.11772    |   0.0 |  0.04
Comm    | 0.12604    | 0.12604    | 0.12604    |   0.0 |  0.05
Output  | 0.00024742 | 0.00024742 | 0.00024742 |   0.0 |  0.00
Modify  | 0.6691     | 0.6691     | 0.6691     |   0.0 |  0.25
Other   |            | 0.0942     |            |       |  0.04

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

Total # of neighbors = 217972
Ave neighs/atom = 54.493
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 = 273.315804798468, Press = -1.10418535605307
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   
      7000  -7872.2821     -7872.2821     -8013.6428     -8013.6428      273.47201      273.47201      124051.31      124051.31      143.12655      143.12655    
      8000  -7871.8795     -7871.8795     -8011.5072     -8011.5072      270.11922      270.11922      124166.68      124166.68     -128.38285     -128.38285    
Loop time of 264.102 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.362 hours/ns, 3.786 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    | 263.09     | 263.09     | 263.09     |   0.0 | 99.62
Neigh   | 0.11796    | 0.11796    | 0.11796    |   0.0 |  0.04
Comm    | 0.12845    | 0.12845    | 0.12845    |   0.0 |  0.05
Output  | 0.00019995 | 0.00019995 | 0.00019995 |   0.0 |  0.00
Modify  | 0.66905    | 0.66905    | 0.66905    |   0.0 |  0.25
Other   |            | 0.0947     |            |       |  0.04

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

Total # of neighbors = 217890
Ave neighs/atom = 54.4725
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 = 273.298037755871, Press = -1.59772231622865
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   
      8000  -7871.8795     -7871.8795     -8011.5072     -8011.5072      270.11922      270.11922      124166.68      124166.68     -128.38285     -128.38285    
      9000  -7876.2358     -7876.2358     -8013.734      -8013.734       265.99963      265.99963      124093.3       124093.3      -41.787357     -41.787357    
Loop time of 264.744 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.326 ns/day, 73.540 hours/ns, 3.777 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    | 263.74     | 263.74     | 263.74     |   0.0 | 99.62
Neigh   | 0.11785    | 0.11785    | 0.11785    |   0.0 |  0.04
Comm    | 0.1266     | 0.1266     | 0.1266     |   0.0 |  0.05
Output  | 0.00019856 | 0.00019856 | 0.00019856 |   0.0 |  0.00
Modify  | 0.66876    | 0.66876    | 0.66876    |   0.0 |  0.25
Other   |            | 0.09452    |            |       |  0.04

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

Total # of neighbors = 217806
Ave neighs/atom = 54.4515
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 = 273.120578736211, Press = 4.13333705618637
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  -7876.2358     -7876.2358     -8013.734      -8013.734       265.99963      265.99963      124093.3       124093.3      -41.787357     -41.787357    
     10000  -7871.1454     -7871.1454     -8013.4613     -8013.4613      275.31984      275.31984      124257.14      124257.14     -572.83822     -572.83822    
Loop time of 264.062 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.351 hours/ns, 3.787 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    | 263.06     | 263.06     | 263.06     |   0.0 | 99.62
Neigh   | 0.11757    | 0.11757    | 0.11757    |   0.0 |  0.04
Comm    | 0.12581    | 0.12581    | 0.12581    |   0.0 |  0.05
Output  | 0.00019654 | 0.00019654 | 0.00019654 |   0.0 |  0.00
Modify  | 0.66786    | 0.66786    | 0.66786    |   0.0 |  0.25
Other   |            | 0.09425    |            |       |  0.04

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

Total # of neighbors = 218194
Ave neighs/atom = 54.5485
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 = 273.395782104274, Press = -2.55675072679544
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  -7871.1454     -7871.1454     -8013.4613     -8013.4613      275.31984      275.31984      124257.14      124257.14     -572.83822     -572.83822    
     11000  -7875.71       -7875.71       -8014.845      -8014.845       269.16617      269.16617      124023.62      124023.62      229.12092      229.12092    
Loop time of 264.954 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.326 ns/day, 73.598 hours/ns, 3.774 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    | 263.95     | 263.95     | 263.95     |   0.0 | 99.62
Neigh   | 0.11788    | 0.11788    | 0.11788    |   0.0 |  0.04
Comm    | 0.12704    | 0.12704    | 0.12704    |   0.0 |  0.05
Output  | 0.00024862 | 0.00024862 | 0.00024862 |   0.0 |  0.00
Modify  | 0.66813    | 0.66813    | 0.66813    |   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:           4913 ave        4913 max        4913 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:       217898 ave      217898 max      217898 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 217898
Ave neighs/atom = 54.4745
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 = 273.331493491596, Press = -0.486731569030667
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  -7875.71       -7875.71       -8014.845      -8014.845       269.16617      269.16617      124023.62      124023.62      229.12092      229.12092    
     12000  -7867.7545     -7867.7545     -8011.9927     -8011.9927      279.03865      279.03865      124185.47      124185.47     -192.23715     -192.23715    
Loop time of 264.157 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.377 hours/ns, 3.786 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    | 263.15     | 263.15     | 263.15     |   0.0 | 99.62
Neigh   | 0.11755    | 0.11755    | 0.11755    |   0.0 |  0.04
Comm    | 0.12661    | 0.12661    | 0.12661    |   0.0 |  0.05
Output  | 0.00019903 | 0.00019903 | 0.00019903 |   0.0 |  0.00
Modify  | 0.66872    | 0.66872    | 0.66872    |   0.0 |  0.25
Other   |            | 0.0939     |            |       |  0.04

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

Total # of neighbors = 217934
Ave neighs/atom = 54.4835
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 = 273.311572886065, Press = 1.98102829466041
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   
     12000  -7867.7545     -7867.7545     -8011.9927     -8011.9927      279.03865      279.03865      124185.47      124185.47     -192.23715     -192.23715    
     13000  -7872.3377     -7872.3377     -8012.8876     -8012.8876      271.90322      271.90322      124069.04      124069.04      145.6621       145.6621     
Loop time of 264.109 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.363 hours/ns, 3.786 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    | 263.06     | 263.06     | 263.06     |   0.0 | 99.60
Neigh   | 0.15698    | 0.15698    | 0.15698    |   0.0 |  0.06
Comm    | 0.1276     | 0.1276     | 0.1276     |   0.0 |  0.05
Output  | 0.00020024 | 0.00020024 | 0.00020024 |   0.0 |  0.00
Modify  | 0.66988    | 0.66988    | 0.66988    |   0.0 |  0.25
Other   |            | 0.09367    |            |       |  0.04

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

Total # of neighbors = 217736
Ave neighs/atom = 54.434
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 = 273.257248934548, Press = -2.65304363708946
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  -7872.3377     -7872.3377     -8012.8876     -8012.8876      271.90322      271.90322      124069.04      124069.04      145.6621       145.6621     
     14000  -7874.2792     -7874.2792     -8011.8514     -8011.8514      266.14271      266.14271      124032.76      124032.76      365.4255       365.4255     
Loop time of 264.868 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.326 ns/day, 73.574 hours/ns, 3.775 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    | 263.86     | 263.86     | 263.86     |   0.0 | 99.62
Neigh   | 0.11764    | 0.11764    | 0.11764    |   0.0 |  0.04
Comm    | 0.12533    | 0.12533    | 0.12533    |   0.0 |  0.05
Output  | 0.00019973 | 0.00019973 | 0.00019973 |   0.0 |  0.00
Modify  | 0.66852    | 0.66852    | 0.66852    |   0.0 |  0.25
Other   |            | 0.09455    |            |       |  0.04

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

Total # of neighbors = 217694
Ave neighs/atom = 54.4235
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 = 273.269895668318, Press = 2.39993708351361
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   
     14000  -7874.2792     -7874.2792     -8011.8514     -8011.8514      266.14271      266.14271      124032.76      124032.76      365.4255       365.4255     
     15000  -7870.4814     -7870.4814     -8012.5387     -8012.5387      274.81956      274.81956      124154.91      124154.91     -133.61692     -133.61692    
Loop time of 264.612 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.327 ns/day, 73.503 hours/ns, 3.779 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    | 263.64     | 263.64     | 263.64     |   0.0 | 99.63
Neigh   | 0.078674   | 0.078674   | 0.078674   |   0.0 |  0.03
Comm    | 0.12688    | 0.12688    | 0.12688    |   0.0 |  0.05
Output  | 0.00023969 | 0.00023969 | 0.00023969 |   0.0 |  0.00
Modify  | 0.66952    | 0.66952    | 0.66952    |   0.0 |  0.25
Other   |            | 0.0944     |            |       |  0.04

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

Total # of neighbors = 217964
Ave neighs/atom = 54.491
Neighbor list builds = 2
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.25868991664, Press = -0.263268665851755
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  -7870.4814     -7870.4814     -8012.5387     -8012.5387      274.81956      274.81956      124154.91      124154.91     -133.61692     -133.61692    
     16000  -7873.4672     -7873.4672     -8014.4188     -8014.4188      272.68045      272.68045      124030.95      124030.95      200.87902      200.87902    
Loop time of 265.591 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.325 ns/day, 73.775 hours/ns, 3.765 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    | 264.58     | 264.58     | 264.58     |   0.0 | 99.62
Neigh   | 0.11821    | 0.11821    | 0.11821    |   0.0 |  0.04
Comm    | 0.12935    | 0.12935    | 0.12935    |   0.0 |  0.05
Output  | 0.0002024  | 0.0002024  | 0.0002024  |   0.0 |  0.00
Modify  | 0.67001    | 0.67001    | 0.67001    |   0.0 |  0.25
Other   |            | 0.09081    |            |       |  0.03

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

Total # of neighbors = 217664
Ave neighs/atom = 54.416
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 = 273.2369189778, Press = 0.57101598155444
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  -7873.4672     -7873.4672     -8014.4188     -8014.4188      272.68045      272.68045      124030.95      124030.95      200.87902      200.87902    
     17000  -7872.9887     -7872.9887     -8015.603      -8015.603       275.89693      275.89693      124112.86      124112.86     -174.61061     -174.61061    
Loop time of 265.721 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.325 ns/day, 73.811 hours/ns, 3.763 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    | 264.71     | 264.71     | 264.71     |   0.0 | 99.62
Neigh   | 0.11831    | 0.11831    | 0.11831    |   0.0 |  0.04
Comm    | 0.12877    | 0.12877    | 0.12877    |   0.0 |  0.05
Output  | 0.00020181 | 0.00020181 | 0.00020181 |   0.0 |  0.00
Modify  | 0.67056    | 0.67056    | 0.67056    |   0.0 |  0.25
Other   |            | 0.09078    |            |       |  0.03

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

Total # of neighbors = 217794
Ave neighs/atom = 54.4485
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 = 273.225810699478, Press = -0.397895622712027
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  -7872.9887     -7872.9887     -8015.603      -8015.603       275.89693      275.89693      124112.86      124112.86     -174.61061     -174.61061    
     18000  -7872.6325     -7872.6325     -8013.2347     -8013.2347      272.00444      272.00444      124007.02      124007.02      373.03737      373.03737    
Loop time of 265.274 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.326 ns/day, 73.687 hours/ns, 3.770 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    | 264.26     | 264.26     | 264.26     |   0.0 | 99.62
Neigh   | 0.11835    | 0.11835    | 0.11835    |   0.0 |  0.04
Comm    | 0.1281     | 0.1281     | 0.1281     |   0.0 |  0.05
Output  | 0.00024029 | 0.00024029 | 0.00024029 |   0.0 |  0.00
Modify  | 0.67144    | 0.67144    | 0.67144    |   0.0 |  0.25
Other   |            | 0.09342    |            |       |  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:       217888 ave      217888 max      217888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 217888
Ave neighs/atom = 54.472
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 = 273.250051833043, Press = -0.720350047741442
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   
     18000  -7872.6325     -7872.6325     -8013.2347     -8013.2347      272.00444      272.00444      124007.02      124007.02      373.03737      373.03737    
     19000  -7871.7824     -7871.7824     -8013.886      -8013.886       274.90918      274.90918      124173.29      124173.29     -302.44219     -302.44219    
Loop time of 265.381 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.326 ns/day, 73.717 hours/ns, 3.768 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    | 264.37     | 264.37     | 264.37     |   0.0 | 99.62
Neigh   | 0.11772    | 0.11772    | 0.11772    |   0.0 |  0.04
Comm    | 0.12814    | 0.12814    | 0.12814    |   0.0 |  0.05
Output  | 0.00020248 | 0.00020248 | 0.00020248 |   0.0 |  0.00
Modify  | 0.66949    | 0.66949    | 0.66949    |   0.0 |  0.25
Other   |            | 0.09235    |            |       |  0.03

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

Total # of neighbors = 217654
Ave neighs/atom = 54.4135
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 = 273.192547142181, Press = 1.68724226450742
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   
     19000  -7871.7824     -7871.7824     -8013.886      -8013.886       274.90918      274.90918      124173.29      124173.29     -302.44219     -302.44219    
     20000  -7870.3199     -7870.3199     -8011.6078     -8011.6078      273.33114      273.33114      124204.23      124204.23     -270.11343     -270.11343    
Loop time of 301.417 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.287 ns/day, 83.727 hours/ns, 3.318 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    | 300.23     | 300.23     | 300.23     |   0.0 | 99.61
Neigh   | 0.12998    | 0.12998    | 0.12998    |   0.0 |  0.04
Comm    | 0.14477    | 0.14477    | 0.14477    |   0.0 |  0.05
Output  | 0.00024983 | 0.00024983 | 0.00024983 |   0.0 |  0.00
Modify  | 0.80988    | 0.80988    | 0.80988    |   0.0 |  0.27
Other   |            | 0.1024     |            |       |  0.03

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

Total # of neighbors = 217868
Ave neighs/atom = 54.467
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 = 273.270954528867, Press = -1.5417730379495
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   
     20000  -7870.3199     -7870.3199     -8011.6078     -8011.6078      273.33114      273.33114      124204.23      124204.23     -270.11343     -270.11343    
     21000  -7875.3551     -7875.3551     -8016.9928     -8016.9928      274.0077       274.0077       123984.25      123984.25      270.54119      270.54119    
Loop time of 312.202 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.277 ns/day, 86.723 hours/ns, 3.203 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 311.01     | 311.01     | 311.01     |   0.0 | 99.62
Neigh   | 0.085944   | 0.085944   | 0.085944   |   0.0 |  0.03
Comm    | 0.14726    | 0.14726    | 0.14726    |   0.0 |  0.05
Output  | 0.00020022 | 0.00020022 | 0.00020022 |   0.0 |  0.00
Modify  | 0.8518     | 0.8518     | 0.8518     |   0.0 |  0.27
Other   |            | 0.1048     |            |       |  0.03

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

Total # of neighbors = 217796
Ave neighs/atom = 54.449
Neighbor list builds = 2
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.257706313124, Press = 0.579751654254597
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   
     21000  -7875.3551     -7875.3551     -8016.9928     -8016.9928      274.0077       274.0077       123984.25      123984.25      270.54119      270.54119    
     22000  -7873.1079     -7873.1079     -8015.2965     -8015.2965      275.07358      275.07358      124250.17      124250.17     -652.29124     -652.29124    
Loop time of 313.82 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.275 ns/day, 87.172 hours/ns, 3.187 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 312.58     | 312.58     | 312.58     |   0.0 | 99.60
Neigh   | 0.13003    | 0.13003    | 0.13003    |   0.0 |  0.04
Comm    | 0.14898    | 0.14898    | 0.14898    |   0.0 |  0.05
Output  | 0.00020146 | 0.00020146 | 0.00020146 |   0.0 |  0.00
Modify  | 0.85696    | 0.85696    | 0.85696    |   0.0 |  0.27
Other   |            | 0.1049     |            |       |  0.03

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

Total # of neighbors = 217710
Ave neighs/atom = 54.4275
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 = 273.183635249717, Press = -0.544630430799379
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   
     22000  -7873.1079     -7873.1079     -8015.2965     -8015.2965      275.07358      275.07358      124250.17      124250.17     -652.29124     -652.29124    
     23000  -7872.4429     -7872.4429     -8012.4176     -8012.4176      270.7904       270.7904       123957.62      123957.62      554.33908      554.33908    
Loop time of 304.286 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.284 ns/day, 84.524 hours/ns, 3.286 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    | 303.09     | 303.09     | 303.09     |   0.0 | 99.61
Neigh   | 0.12603    | 0.12603    | 0.12603    |   0.0 |  0.04
Comm    | 0.14535    | 0.14535    | 0.14535    |   0.0 |  0.05
Output  | 0.00019806 | 0.00019806 | 0.00019806 |   0.0 |  0.00
Modify  | 0.82306    | 0.82306    | 0.82306    |   0.0 |  0.27
Other   |            | 0.1032     |            |       |  0.03

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

Total # of neighbors = 217910
Ave neighs/atom = 54.4775
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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
124101.990348206

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0