# 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.9173715263605122*${_u_distance}
variable latticeconst_converted equal 3.9173715263605122*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.91737152636051
Lattice spacing in x,y,z = 3.9173715 3.9173715 3.9173715
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 (39.173715 39.173715 39.173715)
  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 (39.173715 39.173715 39.173715)
  create_atoms CPU = 0.005 seconds

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

kim_interactions Pt

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

kim interactions Pt
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimSeolJi_2017_PtAl__MO_793141037706_001
pair_coeff * * Pt
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 195.078

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_793141037706_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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -22918.129   -22918.129       -23080       -23080       313.15       313.15    60115.199    60115.199     2876.087     2876.087 
    1000   -22748.002   -22748.002   -22919.059   -22919.059    330.92187    330.92187    60739.134    60739.134    -2735.313    -2735.313 
Loop time of 421.747 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.152 hours/ns, 2.371 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    | 420.64     | 420.64     | 420.64     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21648    | 0.21648    | 0.21648    |   0.0 |  0.05
Output  | 0.00022512 | 0.00022512 | 0.00022512 |   0.0 |  0.00
Modify  | 0.77485    | 0.77485    | 0.77485    |   0.0 |  0.18
Other   |            | 0.1103     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 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:      560000.0 ave      560000 max      560000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 560000
Ave neighs/atom = 140.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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -22748.002   -22748.002   -22919.059   -22919.059    330.92187    330.92187    60739.134    60739.134    -2735.313    -2735.313 
    2000    -22756.51    -22756.51   -22923.269   -22923.269    322.60775    322.60775     60686.67     60686.67   -1067.3121   -1067.3121 
Loop time of 392.982 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.162 hours/ns, 2.545 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    | 392.02     | 392.02     | 392.02     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19928    | 0.19928    | 0.19928    |   0.0 |  0.05
Output  | 0.00021625 | 0.00021625 | 0.00021625 |   0.0 |  0.00
Modify  | 0.66289    | 0.66289    | 0.66289    |   0.0 |  0.17
Other   |            | 0.09852    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8162.00 ave        8162 max        8162 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:      558608.0 ave      558608 max      558608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558608
Ave neighs/atom = 139.65200
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000    -22756.51    -22756.51   -22923.269   -22923.269    322.60775    322.60775     60686.67     60686.67   -1067.3121   -1067.3121 
    3000   -22758.464   -22758.464   -22923.823   -22923.823    319.89695    319.89695    60691.549    60691.549   -1433.6647   -1433.6647 
Loop time of 419.207 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.446 hours/ns, 2.385 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.17     | 418.17     | 418.17     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20843    | 0.20843    | 0.20843    |   0.0 |  0.05
Output  | 0.00022162 | 0.00022162 | 0.00022162 |   0.0 |  0.00
Modify  | 0.72588    | 0.72588    | 0.72588    |   0.0 |  0.17
Other   |            | 0.1041     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8162.00 ave        8162 max        8162 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:      558782.0 ave      558782 max      558782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558782
Ave neighs/atom = 139.69550
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -22758.464   -22758.464   -22923.823   -22923.823    319.89695    319.89695    60691.549    60691.549   -1433.6647   -1433.6647 
    4000   -22753.324   -22753.324   -22920.512   -22920.512    323.43652    323.43652    60628.318    60628.318     2311.018     2311.018 
Loop time of 438.478 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.197 ns/day, 121.799 hours/ns, 2.281 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    | 437.37     | 437.37     | 437.37     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21676    | 0.21676    | 0.21676    |   0.0 |  0.05
Output  | 0.00021559 | 0.00021559 | 0.00021559 |   0.0 |  0.00
Modify  | 0.77737    | 0.77737    | 0.77737    |   0.0 |  0.18
Other   |            | 0.1093     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8157.00 ave        8157 max        8157 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:      558614.0 ave      558614 max      558614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558614
Ave neighs/atom = 139.65350
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -22753.324   -22753.324   -22920.512   -22920.512    323.43652    323.43652    60628.318    60628.318     2311.018     2311.018 
    5000   -22758.552   -22758.552   -22917.089   -22917.089    306.70073    306.70073    60714.536    60714.536   -1675.9829   -1675.9829 
Loop time of 452.363 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.191 ns/day, 125.656 hours/ns, 2.211 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 451.2      | 451.2      | 451.2      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22438    | 0.22438    | 0.22438    |   0.0 |  0.05
Output  | 0.00021686 | 0.00021686 | 0.00021686 |   0.0 |  0.00
Modify  | 0.82291    | 0.82291    | 0.82291    |   0.0 |  0.18
Other   |            | 0.1117     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8169.00 ave        8169 max        8169 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:      558858.0 ave      558858 max      558858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558858
Ave neighs/atom = 139.71450
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 = 316.113308031761, Press = 504.948250019635
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -22758.552   -22758.552   -22917.089   -22917.089    306.70073    306.70073    60714.536    60714.536   -1675.9829   -1675.9829 
    6000   -22757.807   -22757.807   -22921.574   -22921.574    316.81813    316.81813     60618.93     60618.93     2344.188     2344.188 
Loop time of 445.389 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.719 hours/ns, 2.245 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    | 444.25     | 444.25     | 444.25     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21788    | 0.21788    | 0.21788    |   0.0 |  0.05
Output  | 0.00022231 | 0.00022231 | 0.00022231 |   0.0 |  0.00
Modify  | 0.81426    | 0.81426    | 0.81426    |   0.0 |  0.18
Other   |            | 0.1097     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8142.00 ave        8142 max        8142 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:      558516.0 ave      558516 max      558516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558516
Ave neighs/atom = 139.62900
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 = 313.585576601489, Press = 42.274074033767
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -22757.807   -22757.807   -22921.574   -22921.574    316.81813    316.81813     60618.93     60618.93     2344.188     2344.188 
    7000   -22754.957   -22754.957    -22917.17    -22917.17     313.8125     313.8125    60693.822    60693.822   -615.57255   -615.57255 
Loop time of 439.964 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.196 ns/day, 122.212 hours/ns, 2.273 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    | 438.82     | 438.82     | 438.82     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21937    | 0.21937    | 0.21937    |   0.0 |  0.05
Output  | 0.00018109 | 0.00018109 | 0.00018109 |   0.0 |  0.00
Modify  | 0.81247    | 0.81247    | 0.81247    |   0.0 |  0.18
Other   |            | 0.1102     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8161.00 ave        8161 max        8161 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:      558836.0 ave      558836 max      558836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558836
Ave neighs/atom = 139.70900
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 = 312.987105880404, Press = 10.055274068973
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -22754.957   -22754.957    -22917.17    -22917.17     313.8125     313.8125    60693.822    60693.822   -615.57255   -615.57255 
    8000   -22757.677   -22757.677   -22919.102   -22919.102    312.28789    312.28789    60670.182    60670.182    333.63241    333.63241 
Loop time of 429.154 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.209 hours/ns, 2.330 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    | 428.05     | 428.05     | 428.05     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2142     | 0.2142     | 0.2142     |   0.0 |  0.05
Output  | 0.0001817  | 0.0001817  | 0.0001817  |   0.0 |  0.00
Modify  | 0.77798    | 0.77798    | 0.77798    |   0.0 |  0.18
Other   |            | 0.1074     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8166.00 ave        8166 max        8166 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:      558578.0 ave      558578 max      558578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558578
Ave neighs/atom = 139.64450
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 = 313.311443149112, Press = 9.16108308628047
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -22757.677   -22757.677   -22919.102   -22919.102    312.28789    312.28789    60670.182    60670.182    333.63241    333.63241 
    9000   -22757.264   -22757.264   -22920.489   -22920.489    315.76862    315.76862    60654.296    60654.296    802.71215    802.71215 
Loop time of 450.376 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 125.105 hours/ns, 2.220 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    | 449.21     | 449.21     | 449.21     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22217    | 0.22217    | 0.22217    |   0.0 |  0.05
Output  | 0.00024808 | 0.00024808 | 0.00024808 |   0.0 |  0.00
Modify  | 0.83411    | 0.83411    | 0.83411    |   0.0 |  0.19
Other   |            | 0.1112     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8168.00 ave        8168 max        8168 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:      558704.0 ave      558704 max      558704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558704
Ave neighs/atom = 139.67600
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 = 313.150127208305, Press = 13.7274272927706
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -22757.264   -22757.264   -22920.489   -22920.489    315.76862    315.76862    60654.296    60654.296    802.71215    802.71215 
   10000   -22760.123   -22760.123   -22919.311   -22919.311    307.96029    307.96029     60659.84     60659.84    654.19922    654.19922 
Loop time of 433.998 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.555 hours/ns, 2.304 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    | 432.89     | 432.89     | 432.89     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21511    | 0.21511    | 0.21511    |   0.0 |  0.05
Output  | 0.00017943 | 0.00017943 | 0.00017943 |   0.0 |  0.00
Modify  | 0.7811     | 0.7811     | 0.7811     |   0.0 |  0.18
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:        8167.00 ave        8167 max        8167 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:      558710.0 ave      558710 max      558710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558710
Ave neighs/atom = 139.67750
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 = 313.074919304713, Press = 0.317874589231652
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -22760.123   -22760.123   -22919.311   -22919.311    307.96029    307.96029     60659.84     60659.84    654.19922    654.19922 
   11000   -22761.686   -22761.686   -22921.095   -22921.095    308.38739    308.38739    60709.436    60709.436   -1823.4755   -1823.4755 
Loop time of 410.99 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.164 hours/ns, 2.433 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    | 409.94     | 409.94     | 409.94     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21022    | 0.21022    | 0.21022    |   0.0 |  0.05
Output  | 0.00018018 | 0.00018018 | 0.00018018 |   0.0 |  0.00
Modify  | 0.73674    | 0.73674    | 0.73674    |   0.0 |  0.18
Other   |            | 0.1036     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8150.00 ave        8150 max        8150 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:      558670.0 ave      558670 max      558670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558670
Ave neighs/atom = 139.66750
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 = 312.730081331664, Press = 2.33228450838255
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -22761.686   -22761.686   -22921.095   -22921.095    308.38739    308.38739    60709.436    60709.436   -1823.4755   -1823.4755 
   12000   -22756.204   -22756.204   -22918.315   -22918.315      313.614      313.614    60680.398    60680.398   -42.114284   -42.114284 
Loop time of 448.389 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.553 hours/ns, 2.230 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    | 447.22     | 447.22     | 447.22     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22092    | 0.22092    | 0.22092    |   0.0 |  0.05
Output  | 0.0002374  | 0.0002374  | 0.0002374  |   0.0 |  0.00
Modify  | 0.83721    | 0.83721    | 0.83721    |   0.0 |  0.19
Other   |            | 0.1115     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8142.00 ave        8142 max        8142 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:      558600.0 ave      558600 max      558600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558600
Ave neighs/atom = 139.65000
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 = 312.68635631026, Press = 5.81904732791765
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -22756.204   -22756.204   -22918.315   -22918.315      313.614      313.614    60680.398    60680.398   -42.114284   -42.114284 
   13000    -22755.56    -22755.56   -22920.526   -22920.526     319.1382     319.1382    60682.727    60682.727   -423.81398   -423.81398 
Loop time of 444.829 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.564 hours/ns, 2.248 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    | 443.67     | 443.67     | 443.67     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22195    | 0.22195    | 0.22195    |   0.0 |  0.05
Output  | 0.00017637 | 0.00017637 | 0.00017637 |   0.0 |  0.00
Modify  | 0.83071    | 0.83071    | 0.83071    |   0.0 |  0.19
Other   |            | 0.1108     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8164.00 ave        8164 max        8164 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:      558668.0 ave      558668 max      558668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558668
Ave neighs/atom = 139.66700
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 = 312.543780254189, Press = 7.32180836277057
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000    -22755.56    -22755.56   -22920.526   -22920.526     319.1382     319.1382    60682.727    60682.727   -423.81398   -423.81398 
   14000   -22758.128   -22758.128   -22922.435   -22922.435    317.86305    317.86305    60657.069    60657.069    429.80325    429.80325 
Loop time of 451.077 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 125.299 hours/ns, 2.217 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 449.91     | 449.91     | 449.91     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22162    | 0.22162    | 0.22162    |   0.0 |  0.05
Output  | 0.00017882 | 0.00017882 | 0.00017882 |   0.0 |  0.00
Modify  | 0.8379     | 0.8379     | 0.8379     |   0.0 |  0.19
Other   |            | 0.1106     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8155.00 ave        8155 max        8155 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:      558656.0 ave      558656 max      558656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558656
Ave neighs/atom = 139.66400
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 = 312.817938346544, Press = 3.15422335608937
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -22758.128   -22758.128   -22922.435   -22922.435    317.86305    317.86305    60657.069    60657.069    429.80325    429.80325 
   15000   -22753.453   -22753.453   -22914.997   -22914.997    312.51708    312.51708    60685.745    60685.745    151.81554    151.81554 
Loop time of 403.063 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.214 ns/day, 111.962 hours/ns, 2.481 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 402.04     | 402.04     | 402.04     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20409    | 0.20409    | 0.20409    |   0.0 |  0.05
Output  | 0.00023429 | 0.00023429 | 0.00023429 |   0.0 |  0.00
Modify  | 0.72072    | 0.72072    | 0.72072    |   0.0 |  0.18
Other   |            | 0.1022     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8157.00 ave        8157 max        8157 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:      558774.0 ave      558774 max      558774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558774
Ave neighs/atom = 139.69350
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 = 312.886988420743, Press = 2.49680445200549
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -22753.453   -22753.453   -22914.997   -22914.997    312.51708    312.51708    60685.745    60685.745    151.81554    151.81554 
   16000   -22756.896   -22756.896   -22916.844   -22916.844    309.42858    309.42858    60665.679    60665.679    750.58518    750.58518 
Loop time of 382.857 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.349 hours/ns, 2.612 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.9      | 381.9      | 381.9      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19395    | 0.19395    | 0.19395    |   0.0 |  0.05
Output  | 0.00017957 | 0.00017957 | 0.00017957 |   0.0 |  0.00
Modify  | 0.66551    | 0.66551    | 0.66551    |   0.0 |  0.17
Other   |            | 0.09934    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8152.00 ave        8152 max        8152 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:      558622.0 ave      558622 max      558622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558622
Ave neighs/atom = 139.65550
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 = 313.046224445917, Press = 2.67869406002965
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -22756.896   -22756.896   -22916.844   -22916.844    309.42858    309.42858    60665.679    60665.679    750.58518    750.58518 
   17000   -22760.324   -22760.324   -22919.635   -22919.635    308.19713    308.19713     60647.89     60647.89      1154.15      1154.15 
Loop time of 443.134 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.195 ns/day, 123.093 hours/ns, 2.257 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    | 441.98     | 441.98     | 441.98     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21929    | 0.21929    | 0.21929    |   0.0 |  0.05
Output  | 0.00022317 | 0.00022317 | 0.00022317 |   0.0 |  0.00
Modify  | 0.82453    | 0.82453    | 0.82453    |   0.0 |  0.19
Other   |            | 0.1095     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8158.00 ave        8158 max        8158 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:      558674.0 ave      558674 max      558674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558674
Ave neighs/atom = 139.66850
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 = 312.929043503836, Press = 4.3343445177845
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -22760.324   -22760.324   -22919.635   -22919.635    308.19713    308.19713     60647.89     60647.89      1154.15      1154.15 
   18000   -22755.565   -22755.565   -22916.659   -22916.659    311.64856    311.64856    60651.812    60651.812    1440.2507    1440.2507 
Loop time of 445.472 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.742 hours/ns, 2.245 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    | 444.31     | 444.31     | 444.31     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2225     | 0.2225     | 0.2225     |   0.0 |  0.05
Output  | 0.00017866 | 0.00017866 | 0.00017866 |   0.0 |  0.00
Modify  | 0.8314     | 0.8314     | 0.8314     |   0.0 |  0.19
Other   |            | 0.111      |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8158.00 ave        8158 max        8158 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:      558632.0 ave      558632 max      558632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558632
Ave neighs/atom = 139.65800
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 = 312.923772503464, Press = 0.994609998029502
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -22755.565   -22755.565   -22916.659   -22916.659    311.64856    311.64856    60651.812    60651.812    1440.2507    1440.2507 
   19000    -22759.08    -22759.08   -22920.457   -22920.457    312.19421    312.19421    60746.164    60746.164   -3416.9847   -3416.9847 
Loop time of 429.913 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.420 hours/ns, 2.326 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    | 428.79     | 428.79     | 428.79     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21841    | 0.21841    | 0.21841    |   0.0 |  0.05
Output  | 0.0002496  | 0.0002496  | 0.0002496  |   0.0 |  0.00
Modify  | 0.79941    | 0.79941    | 0.79941    |   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:        8155.00 ave        8155 max        8155 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:      558640.0 ave      558640 max      558640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558640
Ave neighs/atom = 139.66000
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 = 312.934872408304, Press = 2.74964253567842
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000    -22759.08    -22759.08   -22920.457   -22920.457    312.19421    312.19421    60746.164    60746.164   -3416.9847   -3416.9847 
   20000   -22756.058   -22756.058   -22918.616   -22918.616    314.47861    314.47861    60642.738    60642.738    1736.3116    1736.3116 
Loop time of 432.641 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.178 hours/ns, 2.311 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.52     | 431.52     | 431.52     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21731    | 0.21731    | 0.21731    |   0.0 |  0.05
Output  | 0.00017919 | 0.00017919 | 0.00017919 |   0.0 |  0.00
Modify  | 0.79658    | 0.79658    | 0.79658    |   0.0 |  0.18
Other   |            | 0.1085     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8153.00 ave        8153 max        8153 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:      558572.0 ave      558572 max      558572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558572
Ave neighs/atom = 139.64300
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 = 312.885753002014, Press = 1.65756026123248
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -22756.058   -22756.058   -22918.616   -22918.616    314.47861    314.47861    60642.738    60642.738    1736.3116    1736.3116 
   21000   -22756.699   -22756.699   -22919.646   -22919.646    315.23327    315.23327    60638.651    60638.651    1686.7106    1686.7106 
Loop time of 425.865 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.296 hours/ns, 2.348 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    | 424.77     | 424.77     | 424.77     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21467    | 0.21467    | 0.21467    |   0.0 |  0.05
Output  | 0.00028425 | 0.00028425 | 0.00028425 |   0.0 |  0.00
Modify  | 0.77792    | 0.77792    | 0.77792    |   0.0 |  0.18
Other   |            | 0.1064     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8162.00 ave        8162 max        8162 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:      558658.0 ave      558658 max      558658 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558658
Ave neighs/atom = 139.66450
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 = 312.901530743662, Press = 3.07527680214077
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -22756.699   -22756.699   -22919.646   -22919.646    315.23327    315.23327    60638.651    60638.651    1686.7106    1686.7106 
   22000   -22758.296   -22758.296   -22919.087   -22919.087    311.06154    311.06154    60625.295    60625.295    2415.1295    2415.1295 
Loop time of 427.055 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.627 hours/ns, 2.342 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 425.96     | 425.96     | 425.96     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21392    | 0.21392    | 0.21392    |   0.0 |  0.05
Output  | 0.0002154  | 0.0002154  | 0.0002154  |   0.0 |  0.00
Modify  | 0.77464    | 0.77464    | 0.77464    |   0.0 |  0.18
Other   |            | 0.1073     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8155.00 ave        8155 max        8155 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:      558668.0 ave      558668 max      558668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558668
Ave neighs/atom = 139.66700
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 = 312.876493629914, Press = 2.64667922071464
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -22758.296   -22758.296   -22919.087   -22919.087    311.06154    311.06154    60625.295    60625.295    2415.1295    2415.1295 
   23000   -22756.683   -22756.683   -22918.129   -22918.129    312.32875    312.32875    60695.134    60695.134   -715.64071   -715.64071 
Loop time of 408.643 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.512 hours/ns, 2.447 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    | 407.6      | 407.6      | 407.6      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20896    | 0.20896    | 0.20896    |   0.0 |  0.05
Output  | 0.000179   | 0.000179   | 0.000179   |   0.0 |  0.00
Modify  | 0.73541    | 0.73541    | 0.73541    |   0.0 |  0.18
Other   |            | 0.1031     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8165.00 ave        8165 max        8165 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:      558654.0 ave      558654 max      558654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558654
Ave neighs/atom = 139.66350
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 = 312.768534172427, Press = 1.10918818684482
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -22756.683   -22756.683   -22918.129   -22918.129    312.32875    312.32875    60695.134    60695.134   -715.64071   -715.64071 
   24000   -22760.641   -22760.641   -22920.874   -22920.874    309.98036    309.98036    60708.105    60708.105   -1815.1458   -1815.1458 
Loop time of 384.296 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.749 hours/ns, 2.602 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    | 383.33     | 383.33     | 383.33     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19772    | 0.19772    | 0.19772    |   0.0 |  0.05
Output  | 0.00018218 | 0.00018218 | 0.00018218 |   0.0 |  0.00
Modify  | 0.6713     | 0.6713     | 0.6713     |   0.0 |  0.17
Other   |            | 0.1002     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8151.00 ave        8151 max        8151 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:      558558.0 ave      558558 max      558558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558558
Ave neighs/atom = 139.63950
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 = 312.744582655409, Press = 0.682843491923156
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -22760.641   -22760.641   -22920.874   -22920.874    309.98036    309.98036    60708.105    60708.105   -1815.1458   -1815.1458 
   25000   -22756.943   -22756.943   -22917.246   -22917.246    310.11561    310.11561    60630.603    60630.603    2369.0854    2369.0854 
Loop time of 384.125 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.701 hours/ns, 2.603 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 383.16     | 383.16     | 383.16     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19754    | 0.19754    | 0.19754    |   0.0 |  0.05
Output  | 0.0001807  | 0.0001807  | 0.0001807  |   0.0 |  0.00
Modify  | 0.66964    | 0.66964    | 0.66964    |   0.0 |  0.17
Other   |            | 0.09967    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8139.00 ave        8139 max        8139 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:      558612.0 ave      558612 max      558612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558612
Ave neighs/atom = 139.65300
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 = 312.789988968635, Press = 2.17636996832734
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -22756.943   -22756.943   -22917.246   -22917.246    310.11561    310.11561    60630.603    60630.603    2369.0854    2369.0854 
   26000   -22759.191   -22759.191   -22920.737   -22920.737    312.52201    312.52201    60689.481    60689.481   -754.34062   -754.34062 
Loop time of 426.788 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.552 hours/ns, 2.343 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 425.69     | 425.69     | 425.69     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21448    | 0.21448    | 0.21448    |   0.0 |  0.05
Output  | 0.00017931 | 0.00017931 | 0.00017931 |   0.0 |  0.00
Modify  | 0.77209    | 0.77209    | 0.77209    |   0.0 |  0.18
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:        8148.00 ave        8148 max        8148 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:      558608.0 ave      558608 max      558608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558608
Ave neighs/atom = 139.65200
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 = 312.762501753186, Press = -0.668207021843145
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -22759.191   -22759.191   -22920.737   -22920.737    312.52201    312.52201    60689.481    60689.481   -754.34062   -754.34062 
   27000   -22751.678   -22751.678   -22918.429   -22918.429    322.59068    322.59068    60682.422    60682.422   -111.30119   -111.30119 
Loop time of 449.395 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 124.832 hours/ns, 2.225 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    | 448.24     | 448.24     | 448.24     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22023    | 0.22023    | 0.22023    |   0.0 |  0.05
Output  | 0.00017846 | 0.00017846 | 0.00017846 |   0.0 |  0.00
Modify  | 0.82093    | 0.82093    | 0.82093    |   0.0 |  0.18
Other   |            | 0.1105     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8155.00 ave        8155 max        8155 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:      558642.0 ave      558642 max      558642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558642
Ave neighs/atom = 139.66050
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 = 312.849240643671, Press = 2.85885659593106
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -22751.678   -22751.678   -22918.429   -22918.429    322.59068    322.59068    60682.422    60682.422   -111.30119   -111.30119 
   28000   -22761.299   -22761.299   -22920.728   -22920.728    308.42635    308.42635    60671.248    60671.248   -138.81272   -138.81272 
Loop time of 422.35 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.319 hours/ns, 2.368 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    | 421.25     | 421.25     | 421.25     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21206    | 0.21206    | 0.21206    |   0.0 |  0.05
Output  | 0.00018123 | 0.00018123 | 0.00018123 |   0.0 |  0.00
Modify  | 0.77794    | 0.77794    | 0.77794    |   0.0 |  0.18
Other   |            | 0.1069     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8147.00 ave        8147 max        8147 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:      558656.0 ave      558656 max      558656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558656
Ave neighs/atom = 139.66400
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 = 312.891600513553, Press = 1.36864898686588
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -22761.299   -22761.299   -22920.728   -22920.728    308.42635    308.42635    60671.248    60671.248   -138.81272   -138.81272 
   29000    -22756.24    -22756.24   -22916.531   -22916.531    310.09265    310.09265    60669.202    60669.202    573.40795    573.40795 
Loop time of 385.092 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 106.970 hours/ns, 2.597 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    | 384.13     | 384.13     | 384.13     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19352    | 0.19352    | 0.19352    |   0.0 |  0.05
Output  | 0.0001795  | 0.0001795  | 0.0001795  |   0.0 |  0.00
Modify  | 0.66802    | 0.66802    | 0.66802    |   0.0 |  0.17
Other   |            | 0.09614    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8146.00 ave        8146 max        8146 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:      558690.0 ave      558690 max      558690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558690
Ave neighs/atom = 139.67250
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 = 312.828467678404, Press = 0.0904726934945193
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000    -22756.24    -22756.24   -22916.531   -22916.531    310.09265    310.09265    60669.202    60669.202    573.40795    573.40795 
   30000   -22758.156   -22758.156   -22918.111   -22918.111    309.44433    309.44433    60627.939    60627.939    2271.6195    2271.6195 
Loop time of 403.681 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.214 ns/day, 112.134 hours/ns, 2.477 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    | 402.67     | 402.67     | 402.67     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20058    | 0.20058    | 0.20058    |   0.0 |  0.05
Output  | 0.00056355 | 0.00056355 | 0.00056355 |   0.0 |  0.00
Modify  | 0.71345    | 0.71345    | 0.71345    |   0.0 |  0.18
Other   |            | 0.1004     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8160.00 ave        8160 max        8160 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:      558510.0 ave      558510 max      558510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558510
Ave neighs/atom = 139.62750
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 = 312.851554320262, Press = 2.74269632848278
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -22758.156   -22758.156   -22918.111   -22918.111    309.44433    309.44433    60627.939    60627.939    2271.6195    2271.6195 
   31000   -22749.482   -22749.482   -22915.782   -22915.782     321.7187     321.7187    60694.161    60694.161   -341.04675   -341.04675 
Loop time of 426.266 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.407 hours/ns, 2.346 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    | 425.18     | 425.18     | 425.18     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20934    | 0.20934    | 0.20934    |   0.0 |  0.05
Output  | 0.00017848 | 0.00017848 | 0.00017848 |   0.0 |  0.00
Modify  | 0.77586    | 0.77586    | 0.77586    |   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:        8161.00 ave        8161 max        8161 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:      558704.0 ave      558704 max      558704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558704
Ave neighs/atom = 139.67600
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 = 312.93207014719, Press = 0.373792674358122
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -22749.482   -22749.482   -22915.782   -22915.782     321.7187     321.7187    60694.161    60694.161   -341.04675   -341.04675 
   32000   -22760.232   -22760.232    -22923.59    -22923.59    316.02796    316.02796     60690.92     60690.92   -1263.7084   -1263.7084 
Loop time of 433.003 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.279 hours/ns, 2.309 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.89     | 431.89     | 431.89     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21338    | 0.21338    | 0.21338    |   0.0 |  0.05
Output  | 0.00017878 | 0.00017878 | 0.00017878 |   0.0 |  0.00
Modify  | 0.7928     | 0.7928     | 0.7928     |   0.0 |  0.18
Other   |            | 0.1076     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8155.00 ave        8155 max        8155 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:      558518.0 ave      558518 max      558518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558518
Ave neighs/atom = 139.62950
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 = 312.98623131506, Press = 2.30268589810937
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 = 8
  ghost atom cutoff = 8
  binsize = 4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -22760.232   -22760.232    -22923.59    -22923.59    316.02796    316.02796     60690.92     60690.92   -1263.7084   -1263.7084 
   33000   -22754.167   -22754.167   -22919.184   -22919.184     319.2358     319.2358    60649.416    60649.416    1314.9745    1314.9745 
Loop time of 417.153 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 115.876 hours/ns, 2.397 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    | 416.09     | 416.09     | 416.09     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20592    | 0.20592    | 0.20592    |   0.0 |  0.05
Output  | 0.00017715 | 0.00017715 | 0.00017715 |   0.0 |  0.00
Modify  | 0.75056    | 0.75056    | 0.75056    |   0.0 |  0.18
Other   |            | 0.1042     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8165.00 ave        8165 max        8165 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:      558686.0 ave      558686 max      558686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 558686
Ave neighs/atom = 139.67150
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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
60675.6523885979

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0