# 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.004 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 253.15*${_u_temperature}
variable temp_converted equal 253.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 253.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 253.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 253.15 253.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  "253.15 - 0.2"
variable      T_up  equal  "253.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   -17669.144   -17669.144       -17800       -17800       253.15       253.15    43665.962    43665.962    3200.8602    3200.8602 
    1000   -17529.326   -17529.326   -17671.559   -17671.559    275.16071    275.16071    44143.366    44143.366   -3375.1326   -3375.1326 
Loop time of 396.949 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 110.264 hours/ns, 2.519 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    | 396.07     | 396.07     | 396.07     |   0.0 | 99.78
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14207    | 0.14207    | 0.14207    |   0.0 |  0.04
Output  | 0.00027111 | 0.00027111 | 0.00027111 |   0.0 |  0.00
Modify  | 0.64098    | 0.64098    | 0.64098    |   0.0 |  0.16
Other   |            | 0.09944    |            |       |  0.03

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   -17529.326   -17529.326   -17671.559   -17671.559    275.16071    275.16071    44143.366    44143.366   -3375.1326   -3375.1326 
    2000   -17538.112   -17538.112   -17666.396   -17666.396    248.17417    248.17417    44040.643    44040.643    1059.6392    1059.6392 
Loop time of 397.698 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.217 ns/day, 110.472 hours/ns, 2.514 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    | 396.78     | 396.78     | 396.78     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14994    | 0.14994    | 0.14994    |   0.0 |  0.04
Output  | 0.00026595 | 0.00026595 | 0.00026595 |   0.0 |  0.00
Modify  | 0.66842    | 0.66842    | 0.66842    |   0.0 |  0.17
Other   |            | 0.101      |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6109.00 ave        6109 max        6109 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:      540836.0 ave      540836 max      540836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540836
Ave neighs/atom = 135.20900
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   -17538.112   -17538.112   -17666.396   -17666.396    248.17417    248.17417    44040.643    44040.643    1059.6392    1059.6392 
    3000   -17536.904   -17536.904   -17667.247   -17667.247     252.1575     252.1575    44082.109    44082.109   -559.27508   -559.27508 
Loop time of 391.532 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.759 hours/ns, 2.554 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    | 390.63     | 390.63     | 390.63     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15009    | 0.15009    | 0.15009    |   0.0 |  0.04
Output  | 0.00026193 | 0.00026193 | 0.00026193 |   0.0 |  0.00
Modify  | 0.6558     | 0.6558     | 0.6558     |   0.0 |  0.17
Other   |            | 0.1011     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6135.00 ave        6135 max        6135 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:      541196.0 ave      541196 max      541196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541196
Ave neighs/atom = 135.29900
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   -17536.904   -17536.904   -17667.247   -17667.247     252.1575     252.1575    44082.109    44082.109   -559.27508   -559.27508 
    4000   -17535.355   -17535.355   -17660.994   -17660.994    243.05635    243.05635    44061.475    44061.475    786.95249    786.95249 
Loop time of 419.619 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.561 hours/ns, 2.383 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    | 418.62     | 418.62     | 418.62     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15955    | 0.15955    | 0.15955    |   0.0 |  0.04
Output  | 0.00026653 | 0.00026653 | 0.00026653 |   0.0 |  0.00
Modify  | 0.73386    | 0.73386    | 0.73386    |   0.0 |  0.17
Other   |            | 0.1024     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6119.00 ave        6119 max        6119 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:      541092.0 ave      541092 max      541092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541092
Ave neighs/atom = 135.27300
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   -17535.355   -17535.355   -17660.994   -17660.994    243.05635    243.05635    44061.475    44061.475    786.95249    786.95249 
    5000   -17539.097   -17539.097   -17669.956   -17669.956    253.15465    253.15465    44041.325    44041.325    863.77981    863.77981 
Loop time of 452.66 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.191 ns/day, 125.739 hours/ns, 2.209 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    | 451.54     | 451.54     | 451.54     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17364    | 0.17364    | 0.17364    |   0.0 |  0.04
Output  | 0.00022994 | 0.00022994 | 0.00022994 |   0.0 |  0.00
Modify  | 0.83364    | 0.83364    | 0.83364    |   0.0 |  0.18
Other   |            | 0.1092     |            |       |  0.02

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:      541300.0 ave      541300 max      541300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541300
Ave neighs/atom = 135.32500
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 = 253.827124598999, Press = -540.260975238479
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   -17539.097   -17539.097   -17669.956   -17669.956    253.15465    253.15465    44041.325    44041.325    863.77981    863.77981 
    6000   -17534.633   -17534.633   -17665.688   -17665.688      253.534      253.534    44116.044    44116.044   -1785.6655   -1785.6655 
Loop time of 452.79 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.191 ns/day, 125.775 hours/ns, 2.209 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    | 451.65     | 451.65     | 451.65     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1738     | 0.1738     | 0.1738     |   0.0 |  0.04
Output  | 0.00022859 | 0.00022859 | 0.00022859 |   0.0 |  0.00
Modify  | 0.85763    | 0.85763    | 0.85763    |   0.0 |  0.19
Other   |            | 0.1101     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6124.00 ave        6124 max        6124 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:      541434.0 ave      541434 max      541434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541434
Ave neighs/atom = 135.35850
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 = 252.95448508074, Press = -25.255258182687
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   -17534.633   -17534.633   -17665.688   -17665.688      253.534      253.534    44116.044    44116.044   -1785.6655   -1785.6655 
    7000   -17539.627   -17539.627   -17666.307   -17666.307    245.07111    245.07111     44017.68     44017.68    2013.9296    2013.9296 
Loop time of 450.496 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 125.138 hours/ns, 2.220 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    | 449.36     | 449.36     | 449.36     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17228    | 0.17228    | 0.17228    |   0.0 |  0.04
Output  | 0.00022645 | 0.00022645 | 0.00022645 |   0.0 |  0.00
Modify  | 0.84796    | 0.84796    | 0.84796    |   0.0 |  0.19
Other   |            | 0.1102     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6168.00 ave        6168 max        6168 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:      540950.0 ave      540950 max      540950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540950
Ave neighs/atom = 135.23750
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 = 253.100219562025, Press = -14.3843397950719
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   -17539.627   -17539.627   -17666.307   -17666.307    245.07111    245.07111     44017.68     44017.68    2013.9296    2013.9296 
    8000   -17537.266   -17537.266   -17667.231   -17667.231    251.42484    251.42484    44103.076    44103.076    -1408.258    -1408.258 
Loop time of 450.919 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 125.255 hours/ns, 2.218 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    | 449.77     | 449.77     | 449.77     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17333    | 0.17333    | 0.17333    |   0.0 |  0.04
Output  | 0.00018031 | 0.00018031 | 0.00018031 |   0.0 |  0.00
Modify  | 0.86094    | 0.86094    | 0.86094    |   0.0 |  0.19
Other   |            | 0.1104     |            |       |  0.02

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:      541400.0 ave      541400 max      541400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541400
Ave neighs/atom = 135.35000
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 = 252.980290623659, Press = -22.950711242705
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 
    8000   -17537.266   -17537.266   -17667.231   -17667.231    251.42484    251.42484    44103.076    44103.076    -1408.258    -1408.258 
    9000   -17536.676   -17536.676   -17668.425   -17668.425    254.87662    254.87662    44054.745    44054.745    585.58479    585.58479 
Loop time of 447.015 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.171 hours/ns, 2.237 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    | 445.9      | 445.9      | 445.9      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16975    | 0.16975    | 0.16975    |   0.0 |  0.04
Output  | 0.00018052 | 0.00018052 | 0.00018052 |   0.0 |  0.00
Modify  | 0.83382    | 0.83382    | 0.83382    |   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:        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:      541012.0 ave      541012 max      541012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541012
Ave neighs/atom = 135.25300
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 = 252.952233813276, Press = -3.87919731669759
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   -17536.676   -17536.676   -17668.425   -17668.425    254.87662    254.87662    44054.745    44054.745    585.58479    585.58479 
   10000   -17537.626   -17537.626   -17668.608   -17668.608    253.39362    253.39362     44078.87     44078.87   -558.91261   -558.91261 
Loop time of 417.551 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 115.986 hours/ns, 2.395 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    | 416.54     | 416.54     | 416.54     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15802    | 0.15802    | 0.15802    |   0.0 |  0.04
Output  | 0.00017703 | 0.00017703 | 0.00017703 |   0.0 |  0.00
Modify  | 0.74844    | 0.74844    | 0.74844    |   0.0 |  0.18
Other   |            | 0.1037     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6121.00 ave        6121 max        6121 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:      541102.0 ave      541102 max      541102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541102
Ave neighs/atom = 135.27550
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 = 252.954954341326, Press = -12.2614020938522
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   -17537.626   -17537.626   -17668.608   -17668.608    253.39362    253.39362     44078.87     44078.87   -558.91261   -558.91261 
   11000   -17540.242   -17540.242   -17670.126   -17670.126    251.26936    251.26936    44076.205    44076.205   -607.38348   -607.38348 
Loop time of 412.228 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.508 hours/ns, 2.426 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    | 411.23     | 411.23     | 411.23     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15732    | 0.15732    | 0.15732    |   0.0 |  0.04
Output  | 0.00018066 | 0.00018066 | 0.00018066 |   0.0 |  0.00
Modify  | 0.74092    | 0.74092    | 0.74092    |   0.0 |  0.18
Other   |            | 0.1034     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6232.00 ave        6232 max        6232 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:      541060.0 ave      541060 max      541060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541060
Ave neighs/atom = 135.26500
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 = 252.926103231778, Press = 1.9994308683666
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.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -17540.242   -17540.242   -17670.126   -17670.126    251.26936    251.26936    44076.205    44076.205   -607.38348   -607.38348 
   12000   -17536.648   -17536.648   -17668.386   -17668.386    254.85747    254.85747    44017.421    44017.421    2039.1992    2039.1992 
Loop time of 450.842 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 125.234 hours/ns, 2.218 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    | 449.69     | 449.69     | 449.69     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17133    | 0.17133    | 0.17133    |   0.0 |  0.04
Output  | 0.00018198 | 0.00018198 | 0.00018198 |   0.0 |  0.00
Modify  | 0.87372    | 0.87372    | 0.87372    |   0.0 |  0.19
Other   |            | 0.1111     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6055.00 ave        6055 max        6055 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:      540914.0 ave      540914 max      540914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540914
Ave neighs/atom = 135.22850
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 = 252.90440892741, Press = -11.9529192099407
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   -17536.648   -17536.648   -17668.386   -17668.386    254.85747    254.85747    44017.421    44017.421    2039.1992    2039.1992 
   13000   -17538.148   -17538.148   -17670.592   -17670.592    256.22169    256.22169    44101.952    44101.952   -1726.1112   -1726.1112 
Loop time of 453.525 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.191 ns/day, 125.979 hours/ns, 2.205 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    | 452.4      | 452.4      | 452.4      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17218    | 0.17218    | 0.17218    |   0.0 |  0.04
Output  | 0.00018017 | 0.00018017 | 0.00018017 |   0.0 |  0.00
Modify  | 0.84652    | 0.84652    | 0.84652    |   0.0 |  0.19
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:        6171.00 ave        6171 max        6171 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 = 252.741513033644, Press = -2.27680953537369
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   -17538.148   -17538.148   -17670.592   -17670.592    256.22169    256.22169    44101.952    44101.952   -1726.1112   -1726.1112 
   14000   -17535.729   -17535.729   -17668.352   -17668.352    256.56822    256.56822    44045.953    44045.953    831.17095    831.17095 
Loop time of 452.828 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.191 ns/day, 125.785 hours/ns, 2.208 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    | 451.7      | 451.7      | 451.7      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17014    | 0.17014    | 0.17014    |   0.0 |  0.04
Output  | 0.00021516 | 0.00021516 | 0.00021516 |   0.0 |  0.00
Modify  | 0.85166    | 0.85166    | 0.85166    |   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:        6105.00 ave        6105 max        6105 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:      540886.0 ave      540886 max      540886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540886
Ave neighs/atom = 135.22150
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 = 252.695616368644, Press = -4.47660364634274
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   -17535.729   -17535.729   -17668.352   -17668.352    256.56822    256.56822    44045.953    44045.953    831.17095    831.17095 
   15000   -17544.186   -17544.186   -17672.029   -17672.029    247.32201    247.32201    44081.518    44081.518   -1114.3245   -1114.3245 
Loop time of 404.875 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.465 hours/ns, 2.470 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.91     | 403.91     | 403.91     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15508    | 0.15508    | 0.15508    |   0.0 |  0.04
Output  | 0.0001794  | 0.0001794  | 0.0001794  |   0.0 |  0.00
Modify  | 0.71108    | 0.71108    | 0.71108    |   0.0 |  0.18
Other   |            | 0.1015     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6198.00 ave        6198 max        6198 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:      541156.0 ave      541156 max      541156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541156
Ave neighs/atom = 135.28900
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 = 252.630505442523, Press = -4.31847168098292
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   -17544.186   -17544.186   -17672.029   -17672.029    247.32201    247.32201    44081.518    44081.518   -1114.3245   -1114.3245 
   16000   -17535.681   -17535.681   -17667.497   -17667.497    255.00775    255.00775    44053.684    44053.684    573.32252    573.32252 
Loop time of 413.966 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.991 hours/ns, 2.416 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.95     | 412.95     | 412.95     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16104    | 0.16104    | 0.16104    |   0.0 |  0.04
Output  | 0.00024552 | 0.00024552 | 0.00024552 |   0.0 |  0.00
Modify  | 0.753      | 0.753      | 0.753      |   0.0 |  0.18
Other   |            | 0.1008     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6166.00 ave        6166 max        6166 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:      540990.0 ave      540990 max      540990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540990
Ave neighs/atom = 135.24750
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 = 252.604916985286, Press = -1.3305799865702
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   -17535.681   -17535.681   -17667.497   -17667.497    255.00775    255.00775    44053.684    44053.684    573.32252    573.32252 
   17000   -17541.409   -17541.409   -17671.587   -17671.587    251.83903    251.83903    44066.663    44066.663   -362.46221   -362.46221 
Loop time of 414.43 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.119 hours/ns, 2.413 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    | 413.42     | 413.42     | 413.42     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16117    | 0.16117    | 0.16117    |   0.0 |  0.04
Output  | 0.00023054 | 0.00023054 | 0.00023054 |   0.0 |  0.00
Modify  | 0.74355    | 0.74355    | 0.74355    |   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:        6213.00 ave        6213 max        6213 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:      541174.0 ave      541174 max      541174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541174
Ave neighs/atom = 135.29350
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 = 252.573079705047, Press = -6.25916528978935
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   -17541.409   -17541.409   -17671.587   -17671.587    251.83903    251.83903    44066.663    44066.663   -362.46221   -362.46221 
   18000   -17536.942   -17536.942   -17666.745   -17666.745    251.11099    251.11099    44073.522    44073.522   -124.24852   -124.24852 
Loop time of 393.305 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.251 hours/ns, 2.543 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.37     | 392.37     | 392.37     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15224    | 0.15224    | 0.15224    |   0.0 |  0.04
Output  | 0.00023551 | 0.00023551 | 0.00023551 |   0.0 |  0.00
Modify  | 0.68159    | 0.68159    | 0.68159    |   0.0 |  0.17
Other   |            | 0.09838    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6153.00 ave        6153 max        6153 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:      541046.0 ave      541046 max      541046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541046
Ave neighs/atom = 135.26150
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 = 252.639359454497, Press = 0.979059938616198
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 
   18000   -17536.942   -17536.942   -17666.745   -17666.745    251.11099    251.11099    44073.522    44073.522   -124.24852   -124.24852 
   19000   -17537.458   -17537.458   -17668.062   -17668.062    252.66201    252.66201    44040.631    44040.631    1099.8341    1099.8341 
Loop time of 449.969 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 124.991 hours/ns, 2.222 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.85     | 448.85     | 448.85     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17198    | 0.17198    | 0.17198    |   0.0 |  0.04
Output  | 0.00022298 | 0.00022298 | 0.00022298 |   0.0 |  0.00
Modify  | 0.84213    | 0.84213    | 0.84213    |   0.0 |  0.19
Other   |            | 0.1092     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6171.00 ave        6171 max        6171 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:      541016.0 ave      541016 max      541016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541016
Ave neighs/atom = 135.25400
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 = 252.615697332265, Press = -5.58546110221917
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 
   19000   -17537.458   -17537.458   -17668.062   -17668.062    252.66201    252.66201    44040.631    44040.631    1099.8341    1099.8341 
   20000   -17537.829   -17537.829   -17667.669   -17667.669     251.1843     251.1843    44105.731    44105.731   -1625.8774   -1625.8774 
Loop time of 450.676 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 125.188 hours/ns, 2.219 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    | 449.57     | 449.57     | 449.57     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17026    | 0.17026    | 0.17026    |   0.0 |  0.04
Output  | 0.00023386 | 0.00023386 | 0.00023386 |   0.0 |  0.00
Modify  | 0.83183    | 0.83183    | 0.83183    |   0.0 |  0.18
Other   |            | 0.1086     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6226.00 ave        6226 max        6226 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 = 252.589981041165, Press = -1.18569346977833
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 
   20000   -17537.829   -17537.829   -17667.669   -17667.669     251.1843     251.1843    44105.731    44105.731   -1625.8774   -1625.8774 
   21000   -17536.074   -17536.074   -17669.284   -17669.284    257.70506    257.70506    44036.234    44036.234    1176.8259    1176.8259 
Loop time of 428.161 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.934 hours/ns, 2.336 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    | 427.11     | 427.11     | 427.11     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16508    | 0.16508    | 0.16508    |   0.0 |  0.04
Output  | 0.00018469 | 0.00018469 | 0.00018469 |   0.0 |  0.00
Modify  | 0.78422    | 0.78422    | 0.78422    |   0.0 |  0.18
Other   |            | 0.1046     |            |       |  0.02

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:      540954.0 ave      540954 max      540954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540954
Ave neighs/atom = 135.23850
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 = 252.624335672775, Press = -2.36782294183114
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 
   21000   -17536.074   -17536.074   -17669.284   -17669.284    257.70506    257.70506    44036.234    44036.234    1176.8259    1176.8259 
   22000   -17542.812   -17542.812   -17669.814   -17669.814    245.69325    245.69325    44086.899    44086.899   -1084.2098   -1084.2098 
Loop time of 444.903 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.584 hours/ns, 2.248 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    | 443.8      | 443.8      | 443.8      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17031    | 0.17031    | 0.17031    |   0.0 |  0.04
Output  | 0.00017831 | 0.00017831 | 0.00017831 |   0.0 |  0.00
Modify  | 0.82868    | 0.82868    | 0.82868    |   0.0 |  0.19
Other   |            | 0.1087     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6218.00 ave        6218 max        6218 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:      541206.0 ave      541206 max      541206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541206
Ave neighs/atom = 135.30150
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 = 252.64598428395, Press = -2.31356095567196
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   -17542.812   -17542.812   -17669.814   -17669.814    245.69325    245.69325    44086.899    44086.899   -1084.2098   -1084.2098 
   23000   -17535.085   -17535.085   -17667.677   -17667.677    256.50819    256.50819    44021.526    44021.526     1962.095     1962.095 
Loop time of 445.814 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.837 hours/ns, 2.243 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.7      | 444.7      | 444.7      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16939    | 0.16939    | 0.16939    |   0.0 |  0.04
Output  | 0.00021819 | 0.00021819 | 0.00021819 |   0.0 |  0.00
Modify  | 0.83866    | 0.83866    | 0.83866    |   0.0 |  0.19
Other   |            | 0.1089     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6124.00 ave        6124 max        6124 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:      541018.0 ave      541018 max      541018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541018
Ave neighs/atom = 135.25450
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 = 252.612535081987, Press = -1.16799430658098
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 
   23000   -17535.085   -17535.085   -17667.677   -17667.677    256.50819    256.50819    44021.526    44021.526     1962.095     1962.095 
   24000     -17537.9     -17537.9   -17666.287   -17666.287    248.37229    248.37229    44120.358    44120.358   -2101.0297   -2101.0297 
Loop time of 451.759 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.191 ns/day, 125.488 hours/ns, 2.214 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    | 450.63     | 450.63     | 450.63     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17527    | 0.17527    | 0.17527    |   0.0 |  0.04
Output  | 0.0001818  | 0.0001818  | 0.0001818  |   0.0 |  0.00
Modify  | 0.84476    | 0.84476    | 0.84476    |   0.0 |  0.19
Other   |            | 0.1079     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6205.00 ave        6205 max        6205 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:      541346.0 ave      541346 max      541346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541346
Ave neighs/atom = 135.33650
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 = 252.652377430581, Press = -4.60291286959174
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     -17537.9     -17537.9   -17666.287   -17666.287    248.37229    248.37229    44120.358    44120.358   -2101.0297   -2101.0297 
   25000   -17537.029   -17537.029   -17666.581   -17666.581    250.62761    250.62761    44040.237    44040.237    1162.5304    1162.5304 
Loop time of 406.479 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.911 hours/ns, 2.460 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    | 405.49     | 405.49     | 405.49     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15935    | 0.15935    | 0.15935    |   0.0 |  0.04
Output  | 0.00017919 | 0.00017919 | 0.00017919 |   0.0 |  0.00
Modify  | 0.73051    | 0.73051    | 0.73051    |   0.0 |  0.18
Other   |            | 0.09988    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6145.00 ave        6145 max        6145 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:      540970.0 ave      540970 max      540970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540970
Ave neighs/atom = 135.24250
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 = 252.658827002124, Press = 0.50351266210838
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   -17537.029   -17537.029   -17666.581   -17666.581    250.62761    250.62761    44040.237    44040.237    1162.5304    1162.5304 
   26000   -17534.007   -17534.007   -17664.688   -17664.688    252.81189    252.81189    44063.994    44063.994    403.92248    403.92248 
Loop time of 447.859 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.405 hours/ns, 2.233 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    | 446.75     | 446.75     | 446.75     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17047    | 0.17047    | 0.17047    |   0.0 |  0.04
Output  | 0.00018781 | 0.00018781 | 0.00018781 |   0.0 |  0.00
Modify  | 0.83068    | 0.83068    | 0.83068    |   0.0 |  0.19
Other   |            | 0.1079     |            |       |  0.02

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:      541314.0 ave      541314 max      541314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541314
Ave neighs/atom = 135.32850
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 = 252.693088757397, Press = -3.29692869478092
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   -17534.007   -17534.007   -17664.688   -17664.688    252.81189    252.81189    44063.994    44063.994    403.92248    403.92248 
   27000   -17538.715   -17538.715    -17668.29    -17668.29    250.67198    250.67198    44084.571    44084.571   -772.71502   -772.71502 
Loop time of 450.088 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 125.024 hours/ns, 2.222 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    | 448.95     | 448.95     | 448.95     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17338    | 0.17338    | 0.17338    |   0.0 |  0.04
Output  | 0.00017693 | 0.00017693 | 0.00017693 |   0.0 |  0.00
Modify  | 0.8519     | 0.8519     | 0.8519     |   0.0 |  0.19
Other   |            | 0.1102     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6187.00 ave        6187 max        6187 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:      541236.0 ave      541236 max      541236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541236
Ave neighs/atom = 135.30900
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 = 252.725436969444, Press = -0.448012912754369
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   -17538.715   -17538.715    -17668.29    -17668.29    250.67198    250.67198    44084.571    44084.571   -772.71502   -772.71502 
   28000   -17536.226   -17536.226       -17667       -17667    252.99156    252.99156    44040.515    44040.515     1259.112     1259.112 
Loop time of 437.595 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.197 ns/day, 121.554 hours/ns, 2.285 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    | 436.5      | 436.5      | 436.5      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16829    | 0.16829    | 0.16829    |   0.0 |  0.04
Output  | 0.00017678 | 0.00017678 | 0.00017678 |   0.0 |  0.00
Modify  | 0.81785    | 0.81785    | 0.81785    |   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:        6191.00 ave        6191 max        6191 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:      541024.0 ave      541024 max      541024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541024
Ave neighs/atom = 135.25600
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 = 252.807921658952, Press = -1.65699752300173
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 
   28000   -17536.226   -17536.226       -17667       -17667    252.99156    252.99156    44040.515    44040.515     1259.112     1259.112 
   29000   -17536.941   -17536.941   -17666.922   -17666.922    251.45812    251.45812    44112.776    44112.776   -1807.4108   -1807.4108 
Loop time of 387.043 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.512 hours/ns, 2.584 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    | 386.14     | 386.14     | 386.14     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14632    | 0.14632    | 0.14632    |   0.0 |  0.04
Output  | 0.00017494 | 0.00017494 | 0.00017494 |   0.0 |  0.00
Modify  | 0.66328    | 0.66328    | 0.66328    |   0.0 |  0.17
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:        6139.00 ave        6139 max        6139 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:      541312.0 ave      541312 max      541312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541312
Ave neighs/atom = 135.32800
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 = 252.855269302175, Press = -1.75964431710803
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 
   29000   -17536.941   -17536.941   -17666.922   -17666.922    251.45812    251.45812    44112.776    44112.776   -1807.4108   -1807.4108 
   30000   -17541.146   -17541.146   -17669.648   -17669.648      248.596      248.596    43968.579    43968.579    3842.2825    3842.2825 
Loop time of 387.136 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.538 hours/ns, 2.583 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    | 386.23     | 386.23     | 386.23     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1465     | 0.1465     | 0.1465     |   0.0 |  0.04
Output  | 0.00017499 | 0.00017499 | 0.00017499 |   0.0 |  0.00
Modify  | 0.66395    | 0.66395    | 0.66395    |   0.0 |  0.17
Other   |            | 0.09879    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6167.00 ave        6167 max        6167 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:      540946.0 ave      540946 max      540946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540946
Ave neighs/atom = 135.23650
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 = 252.869616886593, Press = 1.04785904813192
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 
   30000   -17541.146   -17541.146   -17669.648   -17669.648      248.596      248.596    43968.579    43968.579    3842.2825    3842.2825 
   31000   -17535.734   -17535.734   -17663.804   -17663.804    247.76013    247.76013    44105.669    44105.669   -1204.9948   -1204.9948 
Loop time of 388.891 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.025 hours/ns, 2.571 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    | 387.97     | 387.97     | 387.97     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14749    | 0.14749    | 0.14749    |   0.0 |  0.04
Output  | 0.00017759 | 0.00017759 | 0.00017759 |   0.0 |  0.00
Modify  | 0.66977    | 0.66977    | 0.66977    |   0.0 |  0.17
Other   |            | 0.09893    |            |       |  0.03

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:      541638.0 ave      541638 max      541638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541638
Ave neighs/atom = 135.40950
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 = 252.828446423812, Press = -2.7320906086548
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 
   31000   -17535.734   -17535.734   -17663.804   -17663.804    247.76013    247.76013    44105.669    44105.669   -1204.9948   -1204.9948 
   32000   -17542.717   -17542.717   -17671.705   -17671.705    249.53465    249.53465    44050.756    44050.756     226.0567     226.0567 
Loop time of 389.471 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.186 hours/ns, 2.568 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    | 388.55     | 388.55     | 388.55     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14902    | 0.14902    | 0.14902    |   0.0 |  0.04
Output  | 0.00017594 | 0.00017594 | 0.00017594 |   0.0 |  0.00
Modify  | 0.66988    | 0.66988    | 0.66988    |   0.0 |  0.17
Other   |            | 0.09997    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6167.00 ave        6167 max        6167 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:      540992.0 ave      540992 max      540992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540992
Ave neighs/atom = 135.24800
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 = 252.811293813979, Press = 0.381309531210959
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 
   32000   -17542.717   -17542.717   -17671.705   -17671.705    249.53465    249.53465    44050.756    44050.756     226.0567     226.0567 
   33000   -17537.288   -17537.288   -17668.999   -17668.999    254.80259    254.80259    44056.348    44056.348    380.44942    380.44942 
Loop time of 405.062 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.517 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    | 404.1      | 404.1      | 404.1      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15363    | 0.15363    | 0.15363    |   0.0 |  0.04
Output  | 0.00024837 | 0.00024837 | 0.00024837 |   0.0 |  0.00
Modify  | 0.70841    | 0.70841    | 0.70841    |   0.0 |  0.17
Other   |            | 0.1015     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6151.00 ave        6151 max        6151 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:      541142.0 ave      541142 max      541142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541142
Ave neighs/atom = 135.28550
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 = 252.806212795984, Press = -2.22946642574961
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 
   33000   -17537.288   -17537.288   -17668.999   -17668.999    254.80259    254.80259    44056.348    44056.348    380.44942    380.44942 
   34000   -17532.272   -17532.272   -17666.956   -17666.956    260.55417    260.55417    44095.789    44095.789   -931.46476   -931.46476 
Loop time of 444.973 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.604 hours/ns, 2.247 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    | 443.86     | 443.86     | 443.86     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17065    | 0.17065    | 0.17065    |   0.0 |  0.04
Output  | 0.000178   | 0.000178   | 0.000178   |   0.0 |  0.00
Modify  | 0.83308    | 0.83308    | 0.83308    |   0.0 |  0.19
Other   |            | 0.1103     |            |       |  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:      541184.0 ave      541184 max      541184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541184
Ave neighs/atom = 135.29600
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 = 252.839396029015, Press = -0.642793984722739
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 
   34000   -17532.272   -17532.272   -17666.956   -17666.956    260.55417    260.55417    44095.789    44095.789   -931.46476   -931.46476 
   35000   -17538.292   -17538.292    -17667.49    -17667.49    249.94231    249.94231    44040.488    44040.488    1148.4734    1148.4734 
Loop time of 387.661 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.684 hours/ns, 2.580 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    | 386.75     | 386.75     | 386.75     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14684    | 0.14684    | 0.14684    |   0.0 |  0.04
Output  | 0.00017866 | 0.00017866 | 0.00017866 |   0.0 |  0.00
Modify  | 0.66843    | 0.66843    | 0.66843    |   0.0 |  0.17
Other   |            | 0.09849    |            |       |  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:      540998.0 ave      540998 max      540998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540998
Ave neighs/atom = 135.24950
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 = 252.868000977813, Press = -0.905954419507225
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 
   35000   -17538.292   -17538.292    -17667.49    -17667.49    249.94231    249.94231    44040.488    44040.488    1148.4734    1148.4734 
   36000   -17533.436   -17533.436   -17665.437   -17665.437     255.3652     255.3652    44082.345    44082.345   -342.56426   -342.56426 
Loop time of 388.68 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 107.967 hours/ns, 2.573 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    | 387.77     | 387.77     | 387.77     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1464     | 0.1464     | 0.1464     |   0.0 |  0.04
Output  | 0.00017536 | 0.00017536 | 0.00017536 |   0.0 |  0.00
Modify  | 0.66985    | 0.66985    | 0.66985    |   0.0 |  0.17
Other   |            | 0.09804    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6167.00 ave        6167 max        6167 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:      541226.0 ave      541226 max      541226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541226
Ave neighs/atom = 135.30650
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 = 252.916146101679, Press = -1.25465854570937
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 
   36000   -17533.436   -17533.436   -17665.437   -17665.437     255.3652     255.3652    44082.345    44082.345   -342.56426   -342.56426 
   37000    -17538.76    -17538.76   -17667.242   -17667.242    248.55562    248.55562    44064.996    44064.996    111.40658    111.40658 
Loop time of 387.563 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.656 hours/ns, 2.580 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    | 386.65     | 386.65     | 386.65     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14714    | 0.14714    | 0.14714    |   0.0 |  0.04
Output  | 0.00017582 | 0.00017582 | 0.00017582 |   0.0 |  0.00
Modify  | 0.66563    | 0.66563    | 0.66563    |   0.0 |  0.17
Other   |            | 0.09847    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6139.00 ave        6139 max        6139 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:      540992.0 ave      540992 max      540992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540992
Ave neighs/atom = 135.24800
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 = 252.962098724816, Press = -0.467155783914151
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 
   37000    -17538.76    -17538.76   -17667.242   -17667.242    248.55562    248.55562    44064.996    44064.996    111.40658    111.40658 
   38000    -17536.17    -17536.17   -17667.096   -17667.096    253.28565    253.28565    44049.948    44049.948    812.57571    812.57571 
Loop time of 390.864 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.573 hours/ns, 2.558 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    | 389.94     | 389.94     | 389.94     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14831    | 0.14831    | 0.14831    |   0.0 |  0.04
Output  | 0.00017932 | 0.00017932 | 0.00017932 |   0.0 |  0.00
Modify  | 0.67292    | 0.67292    | 0.67292    |   0.0 |  0.17
Other   |            | 0.09924    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6172.00 ave        6172 max        6172 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:      541152.0 ave      541152 max      541152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541152
Ave neighs/atom = 135.28800
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 = 252.998237954987, Press = -1.12830095519241
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 
   38000    -17536.17    -17536.17   -17667.096   -17667.096    253.28565    253.28565    44049.948    44049.948    812.57571    812.57571 
   39000   -17538.861   -17538.861   -17670.444   -17670.444     254.5568     254.5568    44116.517    44116.517   -2296.7594   -2296.7594 
Loop time of 388.547 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 107.930 hours/ns, 2.574 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    | 387.63     | 387.63     | 387.63     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14634    | 0.14634    | 0.14634    |   0.0 |  0.04
Output  | 0.00017722 | 0.00017722 | 0.00017722 |   0.0 |  0.00
Modify  | 0.66858    | 0.66858    | 0.66858    |   0.0 |  0.17
Other   |            | 0.09978    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6132.00 ave        6132 max        6132 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:      541250.0 ave      541250 max      541250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541250
Ave neighs/atom = 135.31250
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 = 252.984762105124, Press = -1.56640425659755
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 
   39000   -17538.861   -17538.861   -17670.444   -17670.444     254.5568     254.5568    44116.517    44116.517   -2296.7594   -2296.7594 
   40000   -17539.391   -17539.391   -17669.385   -17669.385     251.4816     251.4816    44021.366    44021.366      1788.25      1788.25 
Loop time of 387.444 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.623 hours/ns, 2.581 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    | 386.53     | 386.53     | 386.53     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14721    | 0.14721    | 0.14721    |   0.0 |  0.04
Output  | 0.00017752 | 0.00017752 | 0.00017752 |   0.0 |  0.00
Modify  | 0.66693    | 0.66693    | 0.66693    |   0.0 |  0.17
Other   |            | 0.0983     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6130.00 ave        6130 max        6130 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:      540768.0 ave      540768 max      540768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540768
Ave neighs/atom = 135.19200
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 = 252.991378883351, Press = 0.342724031005793
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 
   40000   -17539.391   -17539.391   -17669.385   -17669.385     251.4816     251.4816    44021.366    44021.366      1788.25      1788.25 
   41000   -17536.385   -17536.385   -17668.226   -17668.226    255.05594    255.05594    44078.354    44078.354    -449.8553    -449.8553 
Loop time of 389.638 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.233 hours/ns, 2.566 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    | 388.72     | 388.72     | 388.72     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14712    | 0.14712    | 0.14712    |   0.0 |  0.04
Output  | 0.00017938 | 0.00017938 | 0.00017938 |   0.0 |  0.00
Modify  | 0.67198    | 0.67198    | 0.67198    |   0.0 |  0.17
Other   |            | 0.0989     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6174.00 ave        6174 max        6174 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:      541240.0 ave      541240 max      541240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541240
Ave neighs/atom = 135.31000
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 = 252.949456544708, Press = -2.25002901407786
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 
   41000   -17536.385   -17536.385   -17668.226   -17668.226    255.05594    255.05594    44078.354    44078.354    -449.8553    -449.8553 
   42000   -17540.442   -17540.442   -17670.515   -17670.515    251.63361    251.63361    44070.762    44070.762   -458.95038   -458.95038 
Loop time of 391.522 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.756 hours/ns, 2.554 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    | 390.6      | 390.6      | 390.6      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15019    | 0.15019    | 0.15019    |   0.0 |  0.04
Output  | 0.00017659 | 0.00017659 | 0.00017659 |   0.0 |  0.00
Modify  | 0.67499    | 0.67499    | 0.67499    |   0.0 |  0.17
Other   |            | 0.09886    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6182.00 ave        6182 max        6182 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:      541084.0 ave      541084 max      541084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541084
Ave neighs/atom = 135.27100
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 = 252.935149315241, Press = -0.167364095612617
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 
   42000   -17540.442   -17540.442   -17670.515   -17670.515    251.63361    251.63361    44070.762    44070.762   -458.95038   -458.95038 
   43000   -17537.237   -17537.237   -17667.694   -17667.694    252.37932    252.37932    44055.573    44055.573    507.90761    507.90761 
Loop time of 388.709 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 107.975 hours/ns, 2.573 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    | 387.79     | 387.79     | 387.79     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14698    | 0.14698    | 0.14698    |   0.0 |  0.04
Output  | 0.00017514 | 0.00017514 | 0.00017514 |   0.0 |  0.00
Modify  | 0.67176    | 0.67176    | 0.67176    |   0.0 |  0.17
Other   |            | 0.09892    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6178.00 ave        6178 max        6178 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:      541054.0 ave      541054 max      541054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541054
Ave neighs/atom = 135.26350
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 = 252.96807776086, Press = -1.32091637694758
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 
   43000   -17537.237   -17537.237   -17667.694   -17667.694    252.37932    252.37932    44055.573    44055.573    507.90761    507.90761 
   44000   -17536.738   -17536.738   -17669.295   -17669.295    256.44018    256.44018    44075.605    44075.605   -514.70001   -514.70001 
Loop time of 389.223 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.117 hours/ns, 2.569 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    | 388.31     | 388.31     | 388.31     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14747    | 0.14747    | 0.14747    |   0.0 |  0.04
Output  | 0.00017748 | 0.00017748 | 0.00017748 |   0.0 |  0.00
Modify  | 0.67086    | 0.67086    | 0.67086    |   0.0 |  0.17
Other   |            | 0.09896    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6154.00 ave        6154 max        6154 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:      541390.0 ave      541390 max      541390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541390
Ave neighs/atom = 135.34750
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 = 252.96448559403, Press = -0.885965186945482
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 
   44000   -17536.738   -17536.738   -17669.295   -17669.295    256.44018    256.44018    44075.605    44075.605   -514.70001   -514.70001 
   45000   -17539.872   -17539.872   -17670.046   -17670.046    251.83159    251.83159    44060.181    44060.181    74.943277    74.943277 
Loop time of 388.261 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.850 hours/ns, 2.576 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    | 387.35     | 387.35     | 387.35     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14714    | 0.14714    | 0.14714    |   0.0 |  0.04
Output  | 0.00023688 | 0.00023688 | 0.00023688 |   0.0 |  0.00
Modify  | 0.66928    | 0.66928    | 0.66928    |   0.0 |  0.17
Other   |            | 0.0989     |            |       |  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:      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 = 252.949750689023, Press = -0.91140025807432
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 
   45000   -17539.872   -17539.872   -17670.046   -17670.046    251.83159    251.83159    44060.181    44060.181    74.943277    74.943277 
   46000   -17532.802   -17532.802   -17665.733   -17665.733    257.16368    257.16368    44080.656    44080.656   -282.34556   -282.34556 
Loop time of 388.897 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.027 hours/ns, 2.571 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    | 387.98     | 387.98     | 387.98     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14823    | 0.14823    | 0.14823    |   0.0 |  0.04
Output  | 0.0001762  | 0.0001762  | 0.0001762  |   0.0 |  0.00
Modify  | 0.67165    | 0.67165    | 0.67165    |   0.0 |  0.17
Other   |            | 0.09854    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6176.00 ave        6176 max        6176 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:      541142.0 ave      541142 max      541142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541142
Ave neighs/atom = 135.28550
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 = 252.975788555851, Press = -0.570552746266138
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 
   46000   -17532.802   -17532.802   -17665.733   -17665.733    257.16368    257.16368    44080.656    44080.656   -282.34556   -282.34556 
   47000   -17538.092   -17538.092   -17669.996   -17669.996    255.17678    255.17678    44056.159    44056.159    237.07432    237.07432 
Loop time of 415.234 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.343 hours/ns, 2.408 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    | 414.23     | 414.23     | 414.23     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15809    | 0.15809    | 0.15809    |   0.0 |  0.04
Output  | 0.00017569 | 0.00017569 | 0.00017569 |   0.0 |  0.00
Modify  | 0.74392    | 0.74392    | 0.74392    |   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:        6151.00 ave        6151 max        6151 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:      541268.0 ave      541268 max      541268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541268
Ave neighs/atom = 135.31700
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 = 252.993176084635, Press = -1.49674797753401
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 
   47000   -17538.092   -17538.092   -17669.996   -17669.996    255.17678    255.17678    44056.159    44056.159    237.07432    237.07432 
   48000   -17535.157   -17535.157   -17667.006   -17667.006     255.0717     255.0717    44107.831    44107.831   -1635.3443   -1635.3443 
Loop time of 388.458 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 107.905 hours/ns, 2.574 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    | 387.54     | 387.54     | 387.54     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14935    | 0.14935    | 0.14935    |   0.0 |  0.04
Output  | 0.00017934 | 0.00017934 | 0.00017934 |   0.0 |  0.00
Modify  | 0.67003    | 0.67003    | 0.67003    |   0.0 |  0.17
Other   |            | 0.0994     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6198.00 ave        6198 max        6198 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:      541174.0 ave      541174 max      541174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541174
Ave neighs/atom = 135.29350
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_T253.15.out"  else  "print 'not_converged'  file output/vol_T253.15.out"
print '${V}'  file output/vol_T253.15.out
44066.8938470508

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0