# 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 3.5213917568326*${_u_distance}
variable latticeconst_converted equal 3.5213917568326*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.5213917568326
Lattice spacing in x,y,z = 3.5213918 3.5213918 3.5213918
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (35.213918 35.213918 35.213918)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (35.213918 35.213918 35.213918)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Ni

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

kim interactions Ni
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KavousiNovakBaskes_2019_NiTi__MO_050461957184_001
pair_coeff * * Ni
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 58.6934

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43665.9617288553 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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_050461957184_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -17648.467   -17648.467       -17800       -17800       293.15       293.15    43665.962    43665.962    3706.6291    3706.6291 
    1000   -17486.006   -17486.006   -17651.226   -17651.226    319.63082    319.63082    44116.766    44116.766    330.31527    330.31527 
Loop time of 423.523 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.645 hours/ns, 2.361 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    | 422.5      | 422.5      | 422.5      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1664     | 0.1664     | 0.1664     |   0.0 |  0.04
Output  | 0.00026473 | 0.00026473 | 0.00026473 |   0.0 |  0.00
Modify  | 0.75645    | 0.75645    | 0.75645    |   0.0 |  0.18
Other   |            | 0.1012     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      536000.0 ave      536000 max      536000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 536000
Ave neighs/atom = 134.00000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -17486.006   -17486.006   -17651.226   -17651.226    319.63082    319.63082    44116.766    44116.766    330.31527    330.31527 
    2000   -17496.658   -17496.658   -17644.548   -17644.548    286.10313    286.10313      44120.4      44120.4    470.28777    470.28777 
Loop time of 419.4 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.500 hours/ns, 2.384 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    | 418.36     | 418.36     | 418.36     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16839    | 0.16839    | 0.16839    |   0.0 |  0.04
Output  | 0.00021736 | 0.00021736 | 0.00021736 |   0.0 |  0.00
Modify  | 0.76428    | 0.76428    | 0.76428    |   0.0 |  0.18
Other   |            | 0.1025     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6169.00 ave        6169 max        6169 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541348.0 ave      541348 max      541348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541348
Ave neighs/atom = 135.33700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -17496.658   -17496.658   -17644.548   -17644.548    286.10313    286.10313      44120.4      44120.4    470.28777    470.28777 
    3000   -17494.713   -17494.713    -17646.82    -17646.82    294.26117    294.26117    44131.774    44131.774   -20.700445   -20.700445 
Loop time of 413.477 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.855 hours/ns, 2.419 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 412.45     | 412.45     | 412.45     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16529    | 0.16529    | 0.16529    |   0.0 |  0.04
Output  | 0.0002436  | 0.0002436  | 0.0002436  |   0.0 |  0.00
Modify  | 0.7604     | 0.7604     | 0.7604     |   0.0 |  0.18
Other   |            | 0.1048     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6147.00 ave        6147 max        6147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541244.0 ave      541244 max      541244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541244
Ave neighs/atom = 135.31100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -17494.713   -17494.713    -17646.82    -17646.82    294.26117    294.26117    44131.774    44131.774   -20.700445   -20.700445 
    4000   -17493.404   -17493.404    -17639.59    -17639.59    282.80607    282.80607    44138.243    44138.243    342.52412    342.52412 
Loop time of 423.231 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.564 hours/ns, 2.363 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    | 422.18     | 422.18     | 422.18     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16842    | 0.16842    | 0.16842    |   0.0 |  0.04
Output  | 0.00021597 | 0.00021597 | 0.00021597 |   0.0 |  0.00
Modify  | 0.78009    | 0.78009    | 0.78009    |   0.0 |  0.18
Other   |            | 0.1058     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6158.00 ave        6158 max        6158 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541170.0 ave      541170 max      541170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541170
Ave neighs/atom = 135.29250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -17493.404   -17493.404    -17639.59    -17639.59    282.80607    282.80607    44138.243    44138.243    342.52412    342.52412 
    5000   -17497.494   -17497.494    -17646.97    -17646.97     289.1716     289.1716    44142.905    44142.905   -546.79983   -546.79983 
Loop time of 433.798 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.499 hours/ns, 2.305 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    | 432.71     | 432.71     | 432.71     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16879    | 0.16879    | 0.16879    |   0.0 |  0.04
Output  | 0.00024592 | 0.00024592 | 0.00024592 |   0.0 |  0.00
Modify  | 0.81041    | 0.81041    | 0.81041    |   0.0 |  0.19
Other   |            | 0.108      |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6169.00 ave        6169 max        6169 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541418.0 ave      541418 max      541418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541418
Ave neighs/atom = 135.35450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.801183154269, Press = -211.833256304835
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -17497.494   -17497.494    -17646.97    -17646.97     289.1716     289.1716    44142.905    44142.905   -546.79983   -546.79983 
    6000     -17492.5     -17492.5   -17645.749   -17645.749    296.47145    296.47145     44132.56     44132.56    102.18623    102.18623 
Loop time of 429.052 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.181 hours/ns, 2.331 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    | 427.96     | 427.96     | 427.96     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16741    | 0.16741    | 0.16741    |   0.0 |  0.04
Output  | 0.00017582 | 0.00017582 | 0.00017582 |   0.0 |  0.00
Modify  | 0.82145    | 0.82145    | 0.82145    |   0.0 |  0.19
Other   |            | 0.1067     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6126.00 ave        6126 max        6126 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541238.0 ave      541238 max      541238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541238
Ave neighs/atom = 135.30950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.855616323849, Press = -48.2723046705353
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000     -17492.5     -17492.5   -17645.749   -17645.749    296.47145    296.47145     44132.56     44132.56    102.18623    102.18623 
    7000   -17498.057   -17498.057   -17646.886   -17646.886    287.91878    287.91878    44080.404    44080.404    1947.2928    1947.2928 
Loop time of 423.302 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.584 hours/ns, 2.362 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    | 422.22     | 422.22     | 422.22     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16585    | 0.16585    | 0.16585    |   0.0 |  0.04
Output  | 0.00023264 | 0.00023264 | 0.00023264 |   0.0 |  0.00
Modify  | 0.808      | 0.808      | 0.808      |   0.0 |  0.19
Other   |            | 0.1058     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6152.00 ave        6152 max        6152 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541204.0 ave      541204 max      541204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541204
Ave neighs/atom = 135.30100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.087988187324, Press = -25.3701963722029
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -17498.057   -17498.057   -17646.886   -17646.886    287.91878    287.91878    44080.404    44080.404    1947.2928    1947.2928 
    8000   -17495.635   -17495.635    -17648.83    -17648.83    296.36522    296.36522     44081.08     44081.08    1912.1766    1912.1766 
Loop time of 433.447 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.402 hours/ns, 2.307 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    | 432.33     | 432.33     | 432.33     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17135    | 0.17135    | 0.17135    |   0.0 |  0.04
Output  | 0.00022768 | 0.00022768 | 0.00022768 |   0.0 |  0.00
Modify  | 0.83635    | 0.83635    | 0.83635    |   0.0 |  0.19
Other   |            | 0.1098     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6152.00 ave        6152 max        6152 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541438.0 ave      541438 max      541438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541438
Ave neighs/atom = 135.35950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.037115268784, Press = -4.39126927064618
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.373 | 5.373 | 5.373 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -17495.635   -17495.635    -17648.83    -17648.83    296.36522    296.36522     44081.08     44081.08    1912.1766    1912.1766 
    9000   -17493.017   -17493.017   -17649.247   -17649.247    302.23815    302.23815      44115.1      44115.1    639.19204    639.19204 
Loop time of 432.518 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.144 hours/ns, 2.312 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    | 431.42     | 431.42     | 431.42     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17118    | 0.17118    | 0.17118    |   0.0 |  0.04
Output  | 0.00018282 | 0.00018282 | 0.00018282 |   0.0 |  0.00
Modify  | 0.82396    | 0.82396    | 0.82396    |   0.0 |  0.19
Other   |            | 0.1065     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6237.00 ave        6237 max        6237 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541342.0 ave      541342 max      541342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541342
Ave neighs/atom = 135.33550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.889695241981, Press = 3.06424218084629
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -17493.017   -17493.017   -17649.247   -17649.247    302.23815    302.23815      44115.1      44115.1    639.19204    639.19204 
   10000   -17499.236   -17499.236   -17647.848   -17647.848     287.5012     287.5012     44118.68     44118.68    341.38715    341.38715 
Loop time of 405.372 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.603 hours/ns, 2.467 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    | 404.35     | 404.35     | 404.35     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16043    | 0.16043    | 0.16043    |   0.0 |  0.04
Output  | 0.00018141 | 0.00018141 | 0.00018141 |   0.0 |  0.00
Modify  | 0.76033    | 0.76033    | 0.76033    |   0.0 |  0.19
Other   |            | 0.1038     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6114.00 ave        6114 max        6114 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541282.0 ave      541282 max      541282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541282
Ave neighs/atom = 135.32050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.775589846054, Press = 4.14949924849627
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.373 | 5.373 | 5.373 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -17499.236   -17499.236   -17647.848   -17647.848     287.5012     287.5012     44118.68     44118.68    341.38715    341.38715 
   11000   -17493.738   -17493.738   -17644.961   -17644.961    292.55135    292.55135    44137.582    44137.582   -78.057168   -78.057168 
Loop time of 411.779 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.383 hours/ns, 2.428 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    | 410.72     | 410.72     | 410.72     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16711    | 0.16711    | 0.16711    |   0.0 |  0.04
Output  | 0.00017853 | 0.00017853 | 0.00017853 |   0.0 |  0.00
Modify  | 0.78325    | 0.78325    | 0.78325    |   0.0 |  0.19
Other   |            | 0.1048     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6242.00 ave        6242 max        6242 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541310.0 ave      541310 max      541310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541310
Ave neighs/atom = 135.32750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.907182376223, Press = 1.66249670243604
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -17493.738   -17493.738   -17644.961   -17644.961    292.55135    292.55135    44137.582    44137.582   -78.057168   -78.057168 
   12000   -17498.359   -17498.359   -17647.763   -17647.763    289.03146    289.03146    44130.661    44130.661   -91.208873   -91.208873 
Loop time of 432.182 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.051 hours/ns, 2.314 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    | 431.07     | 431.07     | 431.07     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16976    | 0.16976    | 0.16976    |   0.0 |  0.04
Output  | 0.00017682 | 0.00017682 | 0.00017682 |   0.0 |  0.00
Modify  | 0.83377    | 0.83377    | 0.83377    |   0.0 |  0.19
Other   |            | 0.1083     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6104.00 ave        6104 max        6104 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541192.0 ave      541192 max      541192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541192
Ave neighs/atom = 135.29800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.912310411864, Press = -1.46055325489873
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -17498.359   -17498.359   -17647.763   -17647.763    289.03146    289.03146    44130.661    44130.661   -91.208873   -91.208873 
   13000   -17492.644   -17492.644   -17641.396   -17641.396    287.77237    287.77237    44138.116    44138.116    185.78801    185.78801 
Loop time of 414.862 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.239 hours/ns, 2.410 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    | 413.8      | 413.8      | 413.8      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16745    | 0.16745    | 0.16745    |   0.0 |  0.04
Output  | 0.00024767 | 0.00024767 | 0.00024767 |   0.0 |  0.00
Modify  | 0.78978    | 0.78978    | 0.78978    |   0.0 |  0.19
Other   |            | 0.1061     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6190.00 ave        6190 max        6190 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541210.0 ave      541210 max      541210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541210
Ave neighs/atom = 135.30250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.802659168392, Press = -1.88012277805064
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -17492.644   -17492.644   -17641.396   -17641.396    287.77237    287.77237    44138.116    44138.116    185.78801    185.78801 
   14000   -17496.361   -17496.361   -17645.239   -17645.239    288.01318    288.01318    44134.065    44134.065   -50.517629   -50.517629 
Loop time of 380.365 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.657 hours/ns, 2.629 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    | 379.41     | 379.41     | 379.41     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15383    | 0.15383    | 0.15383    |   0.0 |  0.04
Output  | 0.00017594 | 0.00017594 | 0.00017594 |   0.0 |  0.00
Modify  | 0.6978     | 0.6978     | 0.6978     |   0.0 |  0.18
Other   |            | 0.09909    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6136.00 ave        6136 max        6136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541256.0 ave      541256 max      541256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541256
Ave neighs/atom = 135.31400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.84735987475, Press = -1.58853885852308
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -17496.361   -17496.361   -17645.239   -17645.239    288.01318    288.01318    44134.065    44134.065   -50.517629   -50.517629 
   15000   -17495.291   -17495.291   -17645.565   -17645.565    290.71426    290.71426    44124.339    44124.339    410.30167    410.30167 
Loop time of 385.736 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.149 hours/ns, 2.592 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    | 384.77     | 384.77     | 384.77     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15497    | 0.15497    | 0.15497    |   0.0 |  0.04
Output  | 0.00017721 | 0.00017721 | 0.00017721 |   0.0 |  0.00
Modify  | 0.70866    | 0.70866    | 0.70866    |   0.0 |  0.18
Other   |            | 0.09968    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6189.00 ave        6189 max        6189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541326.0 ave      541326 max      541326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541326
Ave neighs/atom = 135.33150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.055098338308, Press = -4.97005147572933
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -17495.291   -17495.291   -17645.565   -17645.565    290.71426    290.71426    44124.339    44124.339    410.30167    410.30167 
   16000   -17492.646   -17492.646   -17644.499   -17644.499    293.77136    293.77136    44087.527    44087.527    2051.4201    2051.4201 
Loop time of 404.991 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.497 hours/ns, 2.469 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    | 403.97     | 403.97     | 403.97     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.162      | 0.162      | 0.162      |   0.0 |  0.04
Output  | 0.0001797  | 0.0001797  | 0.0001797  |   0.0 |  0.00
Modify  | 0.76093    | 0.76093    | 0.76093    |   0.0 |  0.19
Other   |            | 0.1024     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6192.00 ave        6192 max        6192 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541246.0 ave      541246 max      541246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541246
Ave neighs/atom = 135.31150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.180051829487, Press = -4.11683604305588
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.373 | 5.373 | 5.373 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -17492.646   -17492.646   -17644.499   -17644.499    293.77136    293.77136    44087.527    44087.527    2051.4201    2051.4201 
   17000   -17499.192   -17499.192    -17647.18    -17647.18    286.29305    286.29305    44070.325    44070.325     2389.428     2389.428 
Loop time of 382.929 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.369 hours/ns, 2.611 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    | 381.97     | 381.97     | 381.97     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15633    | 0.15633    | 0.15633    |   0.0 |  0.04
Output  | 0.00025474 | 0.00025474 | 0.00025474 |   0.0 |  0.00
Modify  | 0.70404    | 0.70404    | 0.70404    |   0.0 |  0.18
Other   |            | 0.09865    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6209.00 ave        6209 max        6209 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541464.0 ave      541464 max      541464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541464
Ave neighs/atom = 135.36600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.165076283607, Press = -1.10442882084764
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -17499.192   -17499.192    -17647.18    -17647.18    286.29305    286.29305    44070.325    44070.325     2389.428     2389.428 
   18000   -17491.756   -17491.756   -17645.439   -17645.439    297.30981    297.30981    44102.828    44102.828     1324.238     1324.238 
Loop time of 410.011 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.892 hours/ns, 2.439 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    | 408.97     | 408.97     | 408.97     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16368    | 0.16368    | 0.16368    |   0.0 |  0.04
Output  | 0.00017836 | 0.00017836 | 0.00017836 |   0.0 |  0.00
Modify  | 0.76943    | 0.76943    | 0.76943    |   0.0 |  0.19
Other   |            | 0.1035     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6152.00 ave        6152 max        6152 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541504.0 ave      541504 max      541504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541504
Ave neighs/atom = 135.37600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.067616701257, Press = 0.32089576385891
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.373 | 5.373 | 5.373 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -17491.756   -17491.756   -17645.439   -17645.439    297.30981    297.30981    44102.828    44102.828     1324.238     1324.238 
   19000   -17498.392   -17498.392   -17646.543   -17646.543    286.60804    286.60804    44116.388    44116.388    614.09209    614.09209 
Loop time of 422.318 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.311 hours/ns, 2.368 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    | 421.24     | 421.24     | 421.24     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16867    | 0.16867    | 0.16867    |   0.0 |  0.04
Output  | 0.00022194 | 0.00022194 | 0.00022194 |   0.0 |  0.00
Modify  | 0.80624    | 0.80624    | 0.80624    |   0.0 |  0.19
Other   |            | 0.1061     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6215.00 ave        6215 max        6215 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541440.0 ave      541440 max      541440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541440
Ave neighs/atom = 135.36000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.076405507743, Press = 0.688951440844937
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -17498.392   -17498.392   -17646.543   -17646.543    286.60804    286.60804    44116.388    44116.388    614.09209    614.09209 
   20000   -17497.185   -17497.185   -17649.213   -17649.213    294.10849    294.10849    44126.849    44126.849   -68.774429   -68.774429 
Loop time of 372.395 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.232 ns/day, 103.443 hours/ns, 2.685 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    | 371.48     | 371.48     | 371.48     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15284    | 0.15284    | 0.15284    |   0.0 |  0.04
Output  | 0.00018061 | 0.00018061 | 0.00018061 |   0.0 |  0.00
Modify  | 0.67124    | 0.67124    | 0.67124    |   0.0 |  0.18
Other   |            | 0.09481    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6188.00 ave        6188 max        6188 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541340.0 ave      541340 max      541340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541340
Ave neighs/atom = 135.33500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.0291469868, Press = 0.237270509569446
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -17497.185   -17497.185   -17649.213   -17649.213    294.10849    294.10849    44126.849    44126.849   -68.774429   -68.774429 
   21000   -17495.314   -17495.314    -17644.58    -17644.58    288.76516    288.76516    44131.818    44131.818    149.28289    149.28289 
Loop time of 373.538 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.761 hours/ns, 2.677 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    | 372.62     | 372.62     | 372.62     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15014    | 0.15014    | 0.15014    |   0.0 |  0.04
Output  | 0.00022112 | 0.00022112 | 0.00022112 |   0.0 |  0.00
Modify  | 0.67272    | 0.67272    | 0.67272    |   0.0 |  0.18
Other   |            | 0.09771    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6186.00 ave        6186 max        6186 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541294.0 ave      541294 max      541294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541294
Ave neighs/atom = 135.32350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.985918339848, Press = -0.766002985153124
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -17495.314   -17495.314    -17644.58    -17644.58    288.76516    288.76516    44131.818    44131.818    149.28289    149.28289 
   22000   -17493.373   -17493.373   -17646.913   -17646.913    297.03235    297.03235    44138.899    44138.899    -294.6807    -294.6807 
Loop time of 431.238 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 119.788 hours/ns, 2.319 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 430.12     | 430.12     | 430.12     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16979    | 0.16979    | 0.16979    |   0.0 |  0.04
Output  | 0.00017754 | 0.00017754 | 0.00017754 |   0.0 |  0.00
Modify  | 0.83658    | 0.83658    | 0.83658    |   0.0 |  0.19
Other   |            | 0.1072     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6175.00 ave        6175 max        6175 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541410.0 ave      541410 max      541410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541410
Ave neighs/atom = 135.35250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.977802707994, Press = -1.06497110414703
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -17493.373   -17493.373   -17646.913   -17646.913    297.03235    297.03235    44138.899    44138.899    -294.6807    -294.6807 
   23000   -17496.711   -17496.711   -17645.373   -17645.373     287.5963     287.5963    44116.663    44116.663    755.98651    755.98651 
Loop time of 420.033 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.676 hours/ns, 2.381 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    | 418.96     | 418.96     | 418.96     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1668     | 0.1668     | 0.1668     |   0.0 |  0.04
Output  | 0.00029006 | 0.00029006 | 0.00029006 |   0.0 |  0.00
Modify  | 0.79799    | 0.79799    | 0.79799    |   0.0 |  0.19
Other   |            | 0.1051     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6163.00 ave        6163 max        6163 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541358.0 ave      541358 max      541358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541358
Ave neighs/atom = 135.33950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.00338643331, Press = -0.626321110251872
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -17496.711   -17496.711   -17645.373   -17645.373     287.5963     287.5963    44116.663    44116.663    755.98651    755.98651 
   24000    -17492.84    -17492.84    -17644.69    -17644.69    293.76356    293.76356     44115.14     44115.14    957.48389    957.48389 
Loop time of 432.444 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.123 hours/ns, 2.312 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 431.34     | 431.34     | 431.34     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1687     | 0.1687     | 0.1687     |   0.0 |  0.04
Output  | 0.00022525 | 0.00022525 | 0.00022525 |   0.0 |  0.00
Modify  | 0.83086    | 0.83086    | 0.83086    |   0.0 |  0.19
Other   |            | 0.109      |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6161.00 ave        6161 max        6161 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541278.0 ave      541278 max      541278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541278
Ave neighs/atom = 135.31950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.902475193902, Press = 0.0457472185524428
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000    -17492.84    -17492.84    -17644.69    -17644.69    293.76356    293.76356     44115.14     44115.14    957.48389    957.48389 
   25000    -17497.36    -17497.36   -17647.182   -17647.182    289.83966    289.83966    44112.215    44112.215    757.54937    757.54937 
Loop time of 420.553 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 116.820 hours/ns, 2.378 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    | 419.48     | 419.48     | 419.48     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16675    | 0.16675    | 0.16675    |   0.0 |  0.04
Output  | 0.00024675 | 0.00024675 | 0.00024675 |   0.0 |  0.00
Modify  | 0.80111    | 0.80111    | 0.80111    |   0.0 |  0.19
Other   |            | 0.1062     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6183.00 ave        6183 max        6183 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541370.0 ave      541370 max      541370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541370
Ave neighs/atom = 135.34250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.901003184115, Press = 0.992732241837393
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000    -17497.36    -17497.36   -17647.182   -17647.182    289.83966    289.83966    44112.215    44112.215    757.54937    757.54937 
   26000   -17490.819   -17490.819    -17646.85    -17646.85    301.85265    301.85265    44137.169    44137.169   -152.67843   -152.67843 
Loop time of 430.422 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.562 hours/ns, 2.323 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 429.32     | 429.32     | 429.32     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16992    | 0.16992    | 0.16992    |   0.0 |  0.04
Output  | 0.00017751 | 0.00017751 | 0.00017751 |   0.0 |  0.00
Modify  | 0.82889    | 0.82889    | 0.82889    |   0.0 |  0.19
Other   |            | 0.1074     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6200.00 ave        6200 max        6200 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541204.0 ave      541204 max      541204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541204
Ave neighs/atom = 135.30100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.993476587095, Press = 1.66881060487788
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -17490.819   -17490.819    -17646.85    -17646.85    301.85265    301.85265    44137.169    44137.169   -152.67843   -152.67843 
   27000   -17498.901   -17498.901   -17648.918   -17648.918     290.2176     290.2176    44159.586    44159.586   -1484.8116   -1484.8116 
Loop time of 418.072 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 116.131 hours/ns, 2.392 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    | 417.01     | 417.01     | 417.01     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16485    | 0.16485    | 0.16485    |   0.0 |  0.04
Output  | 0.00018159 | 0.00018159 | 0.00018159 |   0.0 |  0.00
Modify  | 0.79093    | 0.79093    | 0.79093    |   0.0 |  0.19
Other   |            | 0.1061     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6142.00 ave        6142 max        6142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541256.0 ave      541256 max      541256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541256
Ave neighs/atom = 135.31400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.027217631514, Press = 1.9521168446269
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -17498.901   -17498.901   -17648.918   -17648.918     290.2176     290.2176    44159.586    44159.586   -1484.8116   -1484.8116 
   28000    -17495.81    -17495.81   -17646.742   -17646.742    291.98726    291.98726    44170.523    44170.523   -1590.7981   -1590.7981 
Loop time of 413.609 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.891 hours/ns, 2.418 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    | 412.57     | 412.57     | 412.57     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16421    | 0.16421    | 0.16421    |   0.0 |  0.04
Output  | 0.00017704 | 0.00017704 | 0.00017704 |   0.0 |  0.00
Modify  | 0.77065    | 0.77065    | 0.77065    |   0.0 |  0.19
Other   |            | 0.105      |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6144.00 ave        6144 max        6144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541182.0 ave      541182 max      541182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0