# 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.521391749382019*${_u_distance}
variable latticeconst_converted equal 3.521391749382019*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52139174938202
Lattice spacing in x,y,z = 3.5213917 3.5213917 3.5213917
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.213917 35.213917 35.213917)
  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.213917 35.213917 35.213917)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Ni

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

kim interactions Ni
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_MahataMukhopadhyayAsleZaeem_2022_AlNi__MO_461927113651_000
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.9614516893    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9614516893/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9614516893/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9614516893/(1*1*${_u_distance})
variable      V0_metal equal 43665.9614516893/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 43665.9614516893*1000

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_461927113651_000#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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -17638.129   -17638.129       -17800       -17800       313.15       313.15    43665.961    43665.961    3959.5595    3959.5595 
    1000   -17465.764   -17465.764    -17626.68    -17626.68    311.30453    311.30453    44052.444    44052.444    2556.2353    2556.2353 
Loop time of 374.139 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.928 hours/ns, 2.673 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    | 373.16     | 373.16     | 373.16     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15248    | 0.15248    | 0.15248    |   0.0 |  0.04
Output  | 0.00023025 | 0.00023025 | 0.00023025 |   0.0 |  0.00
Modify  | 0.72457    | 0.72457    | 0.72457    |   0.0 |  0.19
Other   |            | 0.1013     |            |       |  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:      344000.0 ave      344000 max      344000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 344000
Ave neighs/atom = 86.000000
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -17465.764   -17465.764    -17626.68    -17626.68    311.30453    311.30453    44052.444    44052.444    2556.2353    2556.2353 
    2000   -17474.738   -17474.738   -17642.479   -17642.479    324.50543    324.50543    44081.293    44081.293     259.4463     259.4463 
Loop time of 362.399 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.238 ns/day, 100.666 hours/ns, 2.759 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    | 361.51     | 361.51     | 361.51     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14445    | 0.14445    | 0.14445    |   0.0 |  0.04
Output  | 0.00022143 | 0.00022143 | 0.00022143 |   0.0 |  0.00
Modify  | 0.64593    | 0.64593    | 0.64593    |   0.0 |  0.18
Other   |            | 0.09351    |            |       |  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:      341988.0 ave      341988 max      341988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 341988
Ave neighs/atom = 85.497000
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -17474.738   -17474.738   -17642.479   -17642.479    324.50543    324.50543    44081.293    44081.293     259.4463     259.4463 
    3000   -17474.643   -17474.643   -17638.858   -17638.858    317.68532    317.68532    44088.739    44088.739     238.4365     238.4365 
Loop time of 361.638 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.239 ns/day, 100.455 hours/ns, 2.765 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    | 360.75     | 360.75     | 360.75     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14517    | 0.14517    | 0.14517    |   0.0 |  0.04
Output  | 0.00021854 | 0.00021854 | 0.00021854 |   0.0 |  0.00
Modify  | 0.64461    | 0.64461    | 0.64461    |   0.0 |  0.18
Other   |            | 0.09371    |            |       |  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:      342096.0 ave      342096 max      342096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342096
Ave neighs/atom = 85.524000
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -17474.643   -17474.643   -17638.858   -17638.858    317.68532    317.68532    44088.739    44088.739     238.4365     238.4365 
    4000   -17472.071   -17472.071   -17631.864   -17631.864    309.13024    309.13024    44098.239    44098.239    269.88887    269.88887 
Loop time of 360.544 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.240 ns/day, 100.151 hours/ns, 2.774 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    | 359.66     | 359.66     | 359.66     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14396    | 0.14396    | 0.14396    |   0.0 |  0.04
Output  | 0.00021972 | 0.00021972 | 0.00021972 |   0.0 |  0.00
Modify  | 0.64234    | 0.64234    | 0.64234    |   0.0 |  0.18
Other   |            | 0.09423    |            |       |  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:      342106.0 ave      342106 max      342106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342106
Ave neighs/atom = 85.526500
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -17472.071   -17472.071   -17631.864   -17631.864    309.13024    309.13024    44098.239    44098.239    269.88887    269.88887 
    5000   -17476.892   -17476.892   -17636.878   -17636.878    309.50361    309.50361    44103.919    44103.919   -337.90802   -337.90802 
Loop time of 373.617 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.782 hours/ns, 2.677 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    | 372.7      | 372.7      | 372.7      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14762    | 0.14762    | 0.14762    |   0.0 |  0.04
Output  | 0.0002902  | 0.0002902  | 0.0002902  |   0.0 |  0.00
Modify  | 0.67703    | 0.67703    | 0.67703    |   0.0 |  0.18
Other   |            | 0.09675    |            |       |  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:      342080.0 ave      342080 max      342080 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342080
Ave neighs/atom = 85.520000
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 = 311.334814085219, Press = -449.910129443835
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -17476.892   -17476.892   -17636.878   -17636.878    309.50361    309.50361    44103.919    44103.919   -337.90802   -337.90802 
    6000   -17470.995   -17470.995   -17635.087   -17635.087     317.4472     317.4472    44133.561    44133.561   -1355.3036   -1355.3036 
Loop time of 422.243 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.290 hours/ns, 2.368 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 421.14     | 421.14     | 421.14     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16392    | 0.16392    | 0.16392    |   0.0 |  0.04
Output  | 0.00023951 | 0.00023951 | 0.00023951 |   0.0 |  0.00
Modify  | 0.83311    | 0.83311    | 0.83311    |   0.0 |  0.20
Other   |            | 0.1078     |            |       |  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:      342112.0 ave      342112 max      342112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342112
Ave neighs/atom = 85.528000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.744945779124, Press = -43.4953302603563
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -17470.995   -17470.995   -17635.087   -17635.087     317.4472     317.4472    44133.561    44133.561   -1355.3036   -1355.3036 
    7000   -17476.243   -17476.243   -17639.296   -17639.296    315.43779    315.43779    44154.118    44154.118    -2550.732    -2550.732 
Loop time of 390.219 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.394 hours/ns, 2.563 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.22     | 389.22     | 389.22     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15228    | 0.15228    | 0.15228    |   0.0 |  0.04
Output  | 0.00018019 | 0.00018019 | 0.00018019 |   0.0 |  0.00
Modify  | 0.74461    | 0.74461    | 0.74461    |   0.0 |  0.19
Other   |            | 0.0995     |            |       |  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:      341910.0 ave      341910 max      341910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 341910
Ave neighs/atom = 85.477500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.964864081424, Press = -22.0307124675528
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -17476.243   -17476.243   -17639.296   -17639.296    315.43779    315.43779    44154.118    44154.118    -2550.732    -2550.732 
    8000   -17473.697   -17473.697   -17636.006   -17636.006    313.99789    313.99789     44160.62     44160.62   -2547.4124   -2547.4124 
Loop time of 377.59 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.886 hours/ns, 2.648 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    | 376.64     | 376.64     | 376.64     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14951    | 0.14951    | 0.14951    |   0.0 |  0.04
Output  | 0.00017403 | 0.00017403 | 0.00017403 |   0.0 |  0.00
Modify  | 0.70719    | 0.70719    | 0.70719    |   0.0 |  0.19
Other   |            | 0.09696    |            |       |  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:      342032.0 ave      342032 max      342032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342032
Ave neighs/atom = 85.508000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.921084556763, Press = -6.36469670046108
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -17473.697   -17473.697   -17636.006   -17636.006    313.99789    313.99789     44160.62     44160.62   -2547.4124   -2547.4124 
    9000   -17471.856   -17471.856   -17631.547   -17631.547    308.93263    308.93263    44128.474    44128.474   -876.84115   -876.84115 
Loop time of 415.467 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.407 hours/ns, 2.407 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.38     | 414.38     | 414.38     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16257    | 0.16257    | 0.16257    |   0.0 |  0.04
Output  | 0.00026895 | 0.00026895 | 0.00026895 |   0.0 |  0.00
Modify  | 0.8182     | 0.8182     | 0.8182     |   0.0 |  0.20
Other   |            | 0.1051     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      341914.0 ave      341914 max      341914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 341914
Ave neighs/atom = 85.478500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.590473817633, Press = 1.11489705989299
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -17471.856   -17471.856   -17631.547   -17631.547    308.93263    308.93263    44128.474    44128.474   -876.84115   -876.84115 
   10000   -17474.768   -17474.768   -17638.548   -17638.548    316.84456    316.84456    44114.562    44114.562   -865.36691   -865.36691 
Loop time of 421.935 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.204 hours/ns, 2.370 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 420.83     | 420.83     | 420.83     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16371    | 0.16371    | 0.16371    |   0.0 |  0.04
Output  | 0.00025089 | 0.00025089 | 0.00025089 |   0.0 |  0.00
Modify  | 0.83623    | 0.83623    | 0.83623    |   0.0 |  0.20
Other   |            | 0.1069     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      342048.0 ave      342048 max      342048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342048
Ave neighs/atom = 85.512000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.90582011932, Press = -0.687681626456988
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -17474.768   -17474.768   -17638.548   -17638.548    316.84456    316.84456    44114.562    44114.562   -865.36691   -865.36691 
   11000   -17471.624   -17471.624   -17632.505   -17632.505    311.23591    311.23591    44112.333    44112.333   -262.36242   -262.36242 
Loop time of 402.179 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.215 ns/day, 111.716 hours/ns, 2.486 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    | 401.14     | 401.14     | 401.14     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15753    | 0.15753    | 0.15753    |   0.0 |  0.04
Output  | 0.00022116 | 0.00022116 | 0.00022116 |   0.0 |  0.00
Modify  | 0.78117    | 0.78117    | 0.78117    |   0.0 |  0.19
Other   |            | 0.1032     |            |       |  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:      342196.0 ave      342196 max      342196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342196
Ave neighs/atom = 85.549000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.189271829051, Press = 0.304778595244892
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -17471.624   -17471.624   -17632.505   -17632.505    311.23591    311.23591    44112.333    44112.333   -262.36242   -262.36242 
   12000    -17479.89    -17479.89   -17639.079   -17639.079    307.96174    307.96174    44093.937    44093.937   -120.49883   -120.49883 
Loop time of 421.045 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 116.957 hours/ns, 2.375 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 419.95     | 419.95     | 419.95     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16159    | 0.16159    | 0.16159    |   0.0 |  0.04
Output  | 0.00028046 | 0.00028046 | 0.00028046 |   0.0 |  0.00
Modify  | 0.82721    | 0.82721    | 0.82721    |   0.0 |  0.20
Other   |            | 0.1053     |            |       |  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:      342064.0 ave      342064 max      342064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342064
Ave neighs/atom = 85.516000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.095215444323, Press = 0.816555839115201
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000    -17479.89    -17479.89   -17639.079   -17639.079    307.96174    307.96174    44093.937    44093.937   -120.49883   -120.49883 
   13000   -17473.435   -17473.435   -17635.616   -17635.616     313.7502     313.7502    44102.958    44102.958   -126.59282   -126.59282 
Loop time of 387.65 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.681 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.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15276    | 0.15276    | 0.15276    |   0.0 |  0.04
Output  | 0.00017742 | 0.00017742 | 0.00017742 |   0.0 |  0.00
Modify  | 0.74259    | 0.74259    | 0.74259    |   0.0 |  0.19
Other   |            | 0.1004     |            |       |  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:      342318.0 ave      342318 max      342318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342318
Ave neighs/atom = 85.579500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.937006052674, Press = 3.25297652497802
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -17473.435   -17473.435   -17635.616   -17635.616     313.7502     313.7502    44102.958    44102.958   -126.59282   -126.59282 
   14000   -17473.803   -17473.803   -17636.998   -17636.998    315.71156    315.71156     44075.44     44075.44    945.59757    945.59757 
Loop time of 361.337 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.239 ns/day, 100.371 hours/ns, 2.767 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    | 360.44     | 360.44     | 360.44     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14395    | 0.14395    | 0.14395    |   0.0 |  0.04
Output  | 0.00017725 | 0.00017725 | 0.00017725 |   0.0 |  0.00
Modify  | 0.66389    | 0.66389    | 0.66389    |   0.0 |  0.18
Other   |            | 0.09398    |            |       |  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:      342050.0 ave      342050 max      342050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342050
Ave neighs/atom = 85.512500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.882248391906, Press = 3.92183180873196
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -17473.803   -17473.803   -17636.998   -17636.998    315.71156    315.71156     44075.44     44075.44    945.59757    945.59757 
   15000   -17477.487   -17477.487   -17639.385   -17639.385     313.2019     313.2019    44047.332    44047.332    1820.5568    1820.5568 
Loop time of 410.189 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.941 hours/ns, 2.438 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    | 409.13     | 409.13     | 409.13     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15866    | 0.15866    | 0.15866    |   0.0 |  0.04
Output  | 0.00051944 | 0.00051944 | 0.00051944 |   0.0 |  0.00
Modify  | 0.79827    | 0.79827    | 0.79827    |   0.0 |  0.19
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:        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:      342206.0 ave      342206 max      342206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342206
Ave neighs/atom = 85.551500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.789549736971, Press = 1.77496884480663
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -17477.487   -17477.487   -17639.385   -17639.385     313.2019     313.2019    44047.332    44047.332    1820.5568    1820.5568 
   16000    -17472.62    -17472.62   -17635.519   -17635.519    315.13869    315.13869    44054.634    44054.634    1999.4883    1999.4883 
Loop time of 419.396 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.499 hours/ns, 2.384 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.3      | 418.3      | 418.3      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16052    | 0.16052    | 0.16052    |   0.0 |  0.04
Output  | 0.00018268 | 0.00018268 | 0.00018268 |   0.0 |  0.00
Modify  | 0.82726    | 0.82726    | 0.82726    |   0.0 |  0.20
Other   |            | 0.1058     |            |       |  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:      342284.0 ave      342284 max      342284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342284
Ave neighs/atom = 85.571000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.828018618535, Press = -0.881173793174385
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000    -17472.62    -17472.62   -17635.519   -17635.519    315.13869    315.13869    44054.634    44054.634    1999.4883    1999.4883 
   17000   -17472.256   -17472.256   -17636.902   -17636.902    318.51806    318.51806    44062.904    44062.904    1472.3597    1472.3597 
Loop time of 421.248 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.013 hours/ns, 2.374 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    | 420.15     | 420.15     | 420.15     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16286    | 0.16286    | 0.16286    |   0.0 |  0.04
Output  | 0.00030279 | 0.00030279 | 0.00030279 |   0.0 |  0.00
Modify  | 0.83277    | 0.83277    | 0.83277    |   0.0 |  0.20
Other   |            | 0.1065     |            |       |  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:      342140.0 ave      342140 max      342140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342140
Ave neighs/atom = 85.535000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.890193711636, Press = -2.62481372378617
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -17472.256   -17472.256   -17636.902   -17636.902    318.51806    318.51806    44062.904    44062.904    1472.3597    1472.3597 
   18000   -17477.286   -17477.286    -17637.55    -17637.55     310.0414     310.0414    44070.251    44070.251    1090.8228    1090.8228 
Loop time of 423.296 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.582 hours/ns, 2.362 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 422.18     | 422.18     | 422.18     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16491    | 0.16491    | 0.16491    |   0.0 |  0.04
Output  | 0.00023331 | 0.00023331 | 0.00023331 |   0.0 |  0.00
Modify  | 0.84478    | 0.84478    | 0.84478    |   0.0 |  0.20
Other   |            | 0.1068     |            |       |  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:      342120.0 ave      342120 max      342120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342120
Ave neighs/atom = 85.530000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.901372358346, Press = -4.19752275620153
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -17477.286   -17477.286    -17637.55    -17637.55     310.0414     310.0414    44070.251    44070.251    1090.8228    1090.8228 
   19000   -17473.224   -17473.224   -17636.287   -17636.287    315.45663    315.45663    44100.807    44100.807   -46.418382   -46.418382 
Loop time of 388.173 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.826 hours/ns, 2.576 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    | 387.18     | 387.18     | 387.18     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1517     | 0.1517     | 0.1517     |   0.0 |  0.04
Output  | 0.00017551 | 0.00017551 | 0.00017551 |   0.0 |  0.00
Modify  | 0.74073    | 0.74073    | 0.74073    |   0.0 |  0.19
Other   |            | 0.1018     |            |       |  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:      342158.0 ave      342158 max      342158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342158
Ave neighs/atom = 85.539500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.899652531053, Press = -5.34583083810595
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -17473.224   -17473.224   -17636.287   -17636.287    315.45663    315.45663    44100.807    44100.807   -46.418382   -46.418382 
   20000    -17468.72    -17468.72   -17635.882   -17635.882    323.38533    323.38533    44134.835    44134.835   -1358.9573   -1358.9573 
Loop time of 400.739 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 111.316 hours/ns, 2.495 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    | 399.7      | 399.7      | 399.7      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15465    | 0.15465    | 0.15465    |   0.0 |  0.04
Output  | 0.00017938 | 0.00017938 | 0.00017938 |   0.0 |  0.00
Modify  | 0.77776    | 0.77776    | 0.77776    |   0.0 |  0.19
Other   |            | 0.1028     |            |       |  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:      342106.0 ave      342106 max      342106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342106
Ave neighs/atom = 85.526500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.977988378432, Press = -5.97977643655825
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000    -17468.72    -17468.72   -17635.882   -17635.882    323.38533    323.38533    44134.835    44134.835   -1358.9573   -1358.9573 
   21000   -17476.731   -17476.731   -17634.486   -17634.486    305.18651    305.18651    44133.642    44133.642   -1430.1576   -1430.1576 
Loop time of 422.672 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.409 hours/ns, 2.366 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 421.57     | 421.57     | 421.57     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16218    | 0.16218    | 0.16218    |   0.0 |  0.04
Output  | 0.00022613 | 0.00022613 | 0.00022613 |   0.0 |  0.00
Modify  | 0.83427    | 0.83427    | 0.83427    |   0.0 |  0.20
Other   |            | 0.1071     |            |       |  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:      341980.0 ave      341980 max      341980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 341980
Ave neighs/atom = 85.495000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.022164299763, Press = -3.46634987167576
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -17476.731   -17476.731   -17634.486   -17634.486    305.18651    305.18651    44133.642    44133.642   -1430.1576   -1430.1576 
   22000   -17471.951   -17471.951    -17635.15    -17635.15    315.71929    315.71929    44130.004    44130.004   -1257.7521   -1257.7521 
Loop time of 395.515 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 109.865 hours/ns, 2.528 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    | 394.49     | 394.49     | 394.49     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15508    | 0.15508    | 0.15508    |   0.0 |  0.04
Output  | 0.00018094 | 0.00018094 | 0.00018094 |   0.0 |  0.00
Modify  | 0.765      | 0.765      | 0.765      |   0.0 |  0.19
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:        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:      341984.0 ave      341984 max      341984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 341984
Ave neighs/atom = 85.496000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.028499295835, Press = -1.637058927802
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -17471.951   -17471.951    -17635.15    -17635.15    315.71929    315.71929    44130.004    44130.004   -1257.7521   -1257.7521 
   23000   -17477.044   -17477.044   -17638.205   -17638.205    311.77716    311.77716     44116.07     44116.07   -911.79196   -911.79196 
Loop time of 360.953 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.239 ns/day, 100.265 hours/ns, 2.770 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    | 360.05     | 360.05     | 360.05     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14408    | 0.14408    | 0.14408    |   0.0 |  0.04
Output  | 0.00017984 | 0.00017984 | 0.00017984 |   0.0 |  0.00
Modify  | 0.66792    | 0.66792    | 0.66792    |   0.0 |  0.19
Other   |            | 0.09467    |            |       |  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:      342036.0 ave      342036 max      342036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342036
Ave neighs/atom = 85.509000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.046835737468, Press = -1.37221569563774
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -17477.044   -17477.044   -17638.205   -17638.205    311.77716    311.77716     44116.07     44116.07   -911.79196   -911.79196 
   24000   -17466.338   -17466.338   -17632.945   -17632.945    322.31319    322.31319    44136.216    44136.216   -1143.0086   -1143.0086 
Loop time of 377.254 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.793 hours/ns, 2.651 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    | 376.29     | 376.29     | 376.29     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14996    | 0.14996    | 0.14996    |   0.0 |  0.04
Output  | 0.00021925 | 0.00021925 | 0.00021925 |   0.0 |  0.00
Modify  | 0.71475    | 0.71475    | 0.71475    |   0.0 |  0.19
Other   |            | 0.09798    |            |       |  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:      342122.0 ave      342122 max      342122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342122
Ave neighs/atom = 85.530500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.146342803304, Press = -1.08849739674782
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -17466.338   -17466.338   -17632.945   -17632.945    322.31319    322.31319    44136.216    44136.216   -1143.0086   -1143.0086 
   25000   -17475.702   -17475.702    -17633.85    -17633.85    305.94795    305.94795    44158.482    44158.482   -2337.9464   -2337.9464 
Loop time of 413.364 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.823 hours/ns, 2.419 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    | 412.29     | 412.29     | 412.29     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16154    | 0.16154    | 0.16154    |   0.0 |  0.04
Output  | 0.00017994 | 0.00017994 | 0.00017994 |   0.0 |  0.00
Modify  | 0.80285    | 0.80285    | 0.80285    |   0.0 |  0.19
Other   |            | 0.1058     |            |       |  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:      341908.0 ave      341908 max      341908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 341908
Ave neighs/atom = 85.477000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.177823095844, Press = 0.837132100622323
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -17475.702   -17475.702    -17633.85    -17633.85    305.94795    305.94795    44158.482    44158.482   -2337.9464   -2337.9464 
   26000   -17473.099   -17473.099   -17635.706   -17635.706    314.57411    314.57411    44139.812    44139.812   -1662.2219   -1662.2219 
Loop time of 422.988 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.497 hours/ns, 2.364 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    | 421.87     | 421.87     | 421.87     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16649    | 0.16649    | 0.16649    |   0.0 |  0.04
Output  | 0.00017728 | 0.00017728 | 0.00017728 |   0.0 |  0.00
Modify  | 0.84665    | 0.84665    | 0.84665    |   0.0 |  0.20
Other   |            | 0.1071     |            |       |  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:      341966.0 ave      341966 max      341966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 341966
Ave neighs/atom = 85.491500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.248531852646, Press = 1.77726686920886
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -17473.099   -17473.099   -17635.706   -17635.706    314.57411    314.57411    44139.812    44139.812   -1662.2219   -1662.2219 
   27000   -17471.629   -17471.629   -17633.318   -17633.318    312.79774    312.79774    44115.361    44115.361    -407.5559    -407.5559 
Loop time of 399.595 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 110.999 hours/ns, 2.503 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    | 398.56     | 398.56     | 398.56     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15722    | 0.15722    | 0.15722    |   0.0 |  0.04
Output  | 0.00018235 | 0.00018235 | 0.00018235 |   0.0 |  0.00
Modify  | 0.77441    | 0.77441    | 0.77441    |   0.0 |  0.19
Other   |            | 0.1025     |            |       |  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:      341974.0 ave      341974 max      341974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 341974
Ave neighs/atom = 85.493500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.230685221161, Press = 1.16605126793985
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -17471.629   -17471.629   -17633.318   -17633.318    312.79774    312.79774    44115.361    44115.361    -407.5559    -407.5559 
   28000   -17478.797   -17478.797   -17639.179   -17639.179    310.27004    310.27004     44086.02     44086.02    229.00288    229.00288 
Loop time of 377.93 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.981 hours/ns, 2.646 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    | 376.96     | 376.96     | 376.96     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15185    | 0.15185    | 0.15185    |   0.0 |  0.04
Output  | 0.00017935 | 0.00017935 | 0.00017935 |   0.0 |  0.00
Modify  | 0.71937    | 0.71937    | 0.71937    |   0.0 |  0.19
Other   |            | 0.09699    |            |       |  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:      341982.0 ave      341982 max      341982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 341982
Ave neighs/atom = 85.495500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.171592512851, Press = 0.716544920533563
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -17478.797   -17478.797   -17639.179   -17639.179    310.27004    310.27004     44086.02     44086.02    229.00288    229.00288 
   29000   -17473.313   -17473.313   -17634.115   -17634.115    311.08349    311.08349    44080.813    44080.813     923.4024     923.4024 
Loop time of 407.709 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.212 ns/day, 113.253 hours/ns, 2.453 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    | 406.65     | 406.65     | 406.65     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15968    | 0.15968    | 0.15968    |   0.0 |  0.04
Output  | 0.00017778 | 0.00017778 | 0.00017778 |   0.0 |  0.00
Modify  | 0.7978     | 0.7978     | 0.7978     |   0.0 |  0.20
Other   |            | 0.1044     |            |       |  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:      342144.0 ave      342144 max      342144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342144
Ave neighs/atom = 85.536000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.161293411784, Press = 0.365868875054127
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -17473.313   -17473.313   -17634.115   -17634.115    311.08349    311.08349    44080.813    44080.813     923.4024     923.4024 
   30000   -17471.509   -17471.509   -17633.607   -17633.607    313.58896    313.58896     44048.91     44048.91    2370.7746    2370.7746 
Loop time of 391.921 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 108.867 hours/ns, 2.552 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    | 390.91     | 390.91     | 390.91     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15455    | 0.15455    | 0.15455    |   0.0 |  0.04
Output  | 0.00017838 | 0.00017838 | 0.00017838 |   0.0 |  0.00
Modify  | 0.75574    | 0.75574    | 0.75574    |   0.0 |  0.19
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:        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:      342104.0 ave      342104 max      342104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342104
Ave neighs/atom = 85.526000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.116938555029, Press = 0.644574304432853
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -17471.509   -17471.509   -17633.607   -17633.607    313.58896    313.58896     44048.91     44048.91    2370.7746    2370.7746 
   31000   -17472.283   -17472.283   -17633.112   -17633.112     311.1351     311.1351    44014.513    44014.513    3735.5772    3735.5772 
Loop time of 421.142 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 116.984 hours/ns, 2.374 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 420.04     | 420.04     | 420.04     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16193    | 0.16193    | 0.16193    |   0.0 |  0.04
Output  | 0.00017965 | 0.00017965 | 0.00017965 |   0.0 |  0.00
Modify  | 0.8306     | 0.8306     | 0.8306     |   0.0 |  0.20
Other   |            | 0.1062     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      342174.0 ave      342174 max      342174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342174
Ave neighs/atom = 85.543500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.055815668941, Press = -0.267859408786762
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -17472.283   -17472.283   -17633.112   -17633.112     311.1351     311.1351    44014.513    44014.513    3735.5772    3735.5772 
   32000    -17474.02    -17474.02   -17635.598   -17635.598    312.58279    312.58279    44052.332    44052.332    1983.7335    1983.7335 
Loop time of 419.058 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.206 ns/day, 116.405 hours/ns, 2.386 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    | 417.97     | 417.97     | 417.97     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16129    | 0.16129    | 0.16129    |   0.0 |  0.04
Output  | 0.00017759 | 0.00017759 | 0.00017759 |   0.0 |  0.00
Modify  | 0.81884    | 0.81884    | 0.81884    |   0.0 |  0.20
Other   |            | 0.1058     |            |       |  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:      342244.0 ave      342244 max      342244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342244
Ave neighs/atom = 85.561000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.009083429068, Press = -0.986560634505612
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000    -17474.02    -17474.02   -17635.598   -17635.598    312.58279    312.58279    44052.332    44052.332    1983.7335    1983.7335 
   33000   -17478.593   -17478.593   -17639.929   -17639.929    312.11486    312.11486    44073.019    44073.019    728.43761    728.43761 
Loop time of 401.99 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.215 ns/day, 111.664 hours/ns, 2.488 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    | 400.96     | 400.96     | 400.96     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15562    | 0.15562    | 0.15562    |   0.0 |  0.04
Output  | 0.00017964 | 0.00017964 | 0.00017964 |   0.0 |  0.00
Modify  | 0.77219    | 0.77219    | 0.77219    |   0.0 |  0.19
Other   |            | 0.1028     |            |       |  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:      342206.0 ave      342206 max      342206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342206
Ave neighs/atom = 85.551500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.015769832468, Press = -1.37365053339496
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -17478.593   -17478.593   -17639.929   -17639.929    312.11486    312.11486    44073.019    44073.019    728.43761    728.43761 
   34000   -17471.424   -17471.424   -17633.305   -17633.305    313.16925    313.16925    44093.469    44093.469     395.5353     395.5353 
Loop time of 409.712 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.809 hours/ns, 2.441 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 408.65     | 408.65     | 408.65     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15857    | 0.15857    | 0.15857    |   0.0 |  0.04
Output  | 0.00017536 | 0.00017536 | 0.00017536 |   0.0 |  0.00
Modify  | 0.7994     | 0.7994     | 0.7994     |   0.0 |  0.20
Other   |            | 0.1051     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      342236.0 ave      342236 max      342236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342236
Ave neighs/atom = 85.559000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.968918732883, Press = -1.41365170348224
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -17471.424   -17471.424   -17633.305   -17633.305    313.16925    313.16925    44093.469    44093.469     395.5353     395.5353 
   35000     -17477.2     -17477.2   -17637.802   -17637.802    310.69471    310.69471    44097.038    44097.038   -141.42668   -141.42668 
Loop time of 373.921 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.867 hours/ns, 2.674 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    | 372.97     | 372.97     | 372.97     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14708    | 0.14708    | 0.14708    |   0.0 |  0.04
Output  | 0.00021855 | 0.00021855 | 0.00021855 |   0.0 |  0.00
Modify  | 0.70093    | 0.70093    | 0.70093    |   0.0 |  0.19
Other   |            | 0.09934    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      342036.0 ave      342036 max      342036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342036
Ave neighs/atom = 85.509000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.96209918818, Press = -2.09960388882219
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000     -17477.2     -17477.2   -17637.802   -17637.802    310.69471    310.69471    44097.038    44097.038   -141.42668   -141.42668 
   36000     -17472.6     -17472.6   -17632.262   -17632.262    308.87723    308.87723    44140.065    44140.065   -1528.6412   -1528.6412 
Loop time of 407.823 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.212 ns/day, 113.284 hours/ns, 2.452 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    | 406.76     | 406.76     | 406.76     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15873    | 0.15873    | 0.15873    |   0.0 |  0.04
Output  | 0.00023034 | 0.00023034 | 0.00023034 |   0.0 |  0.00
Modify  | 0.80273    | 0.80273    | 0.80273    |   0.0 |  0.20
Other   |            | 0.1046     |            |       |  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:      342146.0 ave      342146 max      342146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342146
Ave neighs/atom = 85.536500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.960481378901, Press = -3.62009991535459
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000     -17472.6     -17472.6   -17632.262   -17632.262    308.87723    308.87723    44140.065    44140.065   -1528.6412   -1528.6412 
   37000   -17477.846   -17477.846   -17639.135   -17639.135    312.02399    312.02399    44138.167    44138.167   -1970.3732   -1970.3732 
Loop time of 395.75 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 109.931 hours/ns, 2.527 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    | 394.74     | 394.74     | 394.74     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15408    | 0.15408    | 0.15408    |   0.0 |  0.04
Output  | 0.00017757 | 0.00017757 | 0.00017757 |   0.0 |  0.00
Modify  | 0.7528     | 0.7528     | 0.7528     |   0.0 |  0.19
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:        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:      341970.0 ave      341970 max      341970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 341970
Ave neighs/atom = 85.492500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.003497071158, Press = -1.72611786424968
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -17477.846   -17477.846   -17639.135   -17639.135    312.02399    312.02399    44138.167    44138.167   -1970.3732   -1970.3732 
   38000   -17473.656   -17473.656   -17634.502   -17634.502    311.16839    311.16839    44137.386    44137.386   -1590.7805   -1590.7805 
Loop time of 361.45 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.239 ns/day, 100.403 hours/ns, 2.767 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    | 360.54     | 360.54     | 360.54     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14583    | 0.14583    | 0.14583    |   0.0 |  0.04
Output  | 0.000179   | 0.000179   | 0.000179   |   0.0 |  0.00
Modify  | 0.66601    | 0.66601    | 0.66601    |   0.0 |  0.18
Other   |            | 0.09501    |            |       |  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:      342042.0 ave      342042 max      342042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342042
Ave neighs/atom = 85.510500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.997863830698, Press = -0.941420303786513
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -17473.656   -17473.656   -17634.502   -17634.502    311.16839    311.16839    44137.386    44137.386   -1590.7805   -1590.7805 
   39000   -17475.302   -17475.302   -17633.911   -17633.911    306.83878    306.83878    44134.187    44134.187   -1399.5324   -1399.5324 
Loop time of 361.865 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.239 ns/day, 100.518 hours/ns, 2.763 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    | 360.96     | 360.96     | 360.96     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14461    | 0.14461    | 0.14461    |   0.0 |  0.04
Output  | 0.00018089 | 0.00018089 | 0.00018089 |   0.0 |  0.00
Modify  | 0.66529    | 0.66529    | 0.66529    |   0.0 |  0.18
Other   |            | 0.09554    |            |       |  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:      341888.0 ave      341888 max      341888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 341888
Ave neighs/atom = 85.472000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.938351296168, Press = -0.309946689176199
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -17475.302   -17475.302   -17633.911   -17633.911    306.83878    306.83878    44134.187    44134.187   -1399.5324   -1399.5324 
   40000   -17474.383   -17474.383   -17638.323   -17638.323    317.15194    317.15194    44134.264    44134.264   -1657.1389   -1657.1389 
Loop time of 384.314 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.754 hours/ns, 2.602 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 383.34     | 383.34     | 383.34     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15001    | 0.15001    | 0.15001    |   0.0 |  0.04
Output  | 0.00021412 | 0.00021412 | 0.00021412 |   0.0 |  0.00
Modify  | 0.72707    | 0.72707    | 0.72707    |   0.0 |  0.19
Other   |            | 0.1004     |            |       |  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:      342014.0 ave      342014 max      342014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342014
Ave neighs/atom = 85.503500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.947054311582, Press = -0.0899241419113457
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -17474.383   -17474.383   -17638.323   -17638.323    317.15194    317.15194    44134.264    44134.264   -1657.1389   -1657.1389 
   41000   -17477.589   -17477.589    -17638.07    -17638.07    310.46204    310.46204    44135.606    44135.606   -1721.6999   -1721.6999 
Loop time of 414.371 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 115.103 hours/ns, 2.413 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    | 413.29     | 413.29     | 413.29     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16004    | 0.16004    | 0.16004    |   0.0 |  0.04
Output  | 0.00025877 | 0.00025877 | 0.00025877 |   0.0 |  0.00
Modify  | 0.81589    | 0.81589    | 0.81589    |   0.0 |  0.20
Other   |            | 0.1068     |            |       |  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:      342152.0 ave      342152 max      342152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342152
Ave neighs/atom = 85.538000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.890555244694, Press = 0.317542184830861
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -17477.589   -17477.589    -17638.07    -17638.07    310.46204    310.46204    44135.606    44135.606   -1721.6999   -1721.6999 
   42000   -17475.869   -17475.869   -17636.577   -17636.577    310.90161    310.90161    44144.131    44144.131   -2051.1687   -2051.1687 
Loop time of 389.155 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.099 hours/ns, 2.570 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    | 388.15     | 388.15     | 388.15     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15425    | 0.15425    | 0.15425    |   0.0 |  0.04
Output  | 0.00017719 | 0.00017719 | 0.00017719 |   0.0 |  0.00
Modify  | 0.74483    | 0.74483    | 0.74483    |   0.0 |  0.19
Other   |            | 0.1018     |            |       |  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:      342082.0 ave      342082 max      342082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342082
Ave neighs/atom = 85.520500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.899051351854, Press = 1.29435869781348
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -17475.869   -17475.869   -17636.577   -17636.577    310.90161    310.90161    44144.131    44144.131   -2051.1687   -2051.1687 
   43000   -17472.887   -17472.887   -17636.635   -17636.635    316.78231    316.78231    44115.699    44115.699   -748.94583   -748.94583 
Loop time of 381.889 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.080 hours/ns, 2.619 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    | 380.92     | 380.92     | 380.92     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14967    | 0.14967    | 0.14967    |   0.0 |  0.04
Output  | 0.0001783  | 0.0001783  | 0.0001783  |   0.0 |  0.00
Modify  | 0.7214     | 0.7214     | 0.7214     |   0.0 |  0.19
Other   |            | 0.1003     |            |       |  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:      341980.0 ave      341980 max      341980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 341980
Ave neighs/atom = 85.495000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.880591178906, Press = 1.53264355902727
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -17472.887   -17472.887   -17636.635   -17636.635    316.78231    316.78231    44115.699    44115.699   -748.94583   -748.94583 
   44000   -17477.803   -17477.803   -17640.667   -17640.667    315.07041    315.07041    44093.469    44093.469   -173.63469   -173.63469 
Loop time of 405.12 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.533 hours/ns, 2.468 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    | 404.07     | 404.07     | 404.07     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15663    | 0.15663    | 0.15663    |   0.0 |  0.04
Output  | 0.00023465 | 0.00023465 | 0.00023465 |   0.0 |  0.00
Modify  | 0.78491    | 0.78491    | 0.78491    |   0.0 |  0.19
Other   |            | 0.1049     |            |       |  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:      341970.0 ave      341970 max      341970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 341970
Ave neighs/atom = 85.492500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.889759214511, Press = 0.524069723942334
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -17477.803   -17477.803   -17640.667   -17640.667    315.07041    315.07041    44093.469    44093.469   -173.63469   -173.63469 
   45000    -17473.95    -17473.95   -17635.563   -17635.563    312.65123    312.65123    44091.213    44091.213    301.70786    301.70786 
Loop time of 413.588 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.886 hours/ns, 2.418 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 412.51     | 412.51     | 412.51     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16031    | 0.16031    | 0.16031    |   0.0 |  0.04
Output  | 0.00017938 | 0.00017938 | 0.00017938 |   0.0 |  0.00
Modify  | 0.80741    | 0.80741    | 0.80741    |   0.0 |  0.20
Other   |            | 0.1056     |            |       |  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:      342202.0 ave      342202 max      342202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342202
Ave neighs/atom = 85.550500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.900773688675, Press = 0.424354045513035
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000    -17473.95    -17473.95   -17635.563   -17635.563    312.65123    312.65123    44091.213    44091.213    301.70786    301.70786 
   46000    -17471.77    -17471.77    -17635.59    -17635.59    316.91985    316.91985    44080.261    44080.261    830.33954    830.33954 
Loop time of 389.949 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.319 hours/ns, 2.564 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    | 388.95     | 388.95     | 388.95     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15381    | 0.15381    | 0.15381    |   0.0 |  0.04
Output  | 0.00017705 | 0.00017705 | 0.00017705 |   0.0 |  0.00
Modify  | 0.74482    | 0.74482    | 0.74482    |   0.0 |  0.19
Other   |            | 0.1026     |            |       |  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:      342086.0 ave      342086 max      342086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342086
Ave neighs/atom = 85.521500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.903747751546, Press = 0.321883749135379
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000    -17471.77    -17471.77    -17635.59    -17635.59    316.91985    316.91985    44080.261    44080.261    830.33954    830.33954 
   47000    -17481.15    -17481.15   -17638.978   -17638.978    305.32788    305.32788     44009.77     44009.77    3358.1759    3358.1759 
Loop time of 400.774 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 111.326 hours/ns, 2.495 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    | 399.73     | 399.73     | 399.73     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15677    | 0.15677    | 0.15677    |   0.0 |  0.04
Output  | 0.0001778  | 0.0001778  | 0.0001778  |   0.0 |  0.00
Modify  | 0.78478    | 0.78478    | 0.78478    |   0.0 |  0.20
Other   |            | 0.1056     |            |       |  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:      342118.0 ave      342118 max      342118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342118
Ave neighs/atom = 85.529500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.874936595819, Press = 1.14308755741549
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000    -17481.15    -17481.15   -17638.978   -17638.978    305.32788    305.32788     44009.77     44009.77    3358.1759    3358.1759 
   48000   -17471.266   -17471.266   -17634.055   -17634.055    314.92539    314.92539    44013.731    44013.731    3797.8172    3797.8172 
Loop time of 359.853 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.240 ns/day, 99.959 hours/ns, 2.779 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    | 358.94     | 358.94     | 358.94     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1431     | 0.1431     | 0.1431     |   0.0 |  0.04
Output  | 0.00017625 | 0.00017625 | 0.00017625 |   0.0 |  0.00
Modify  | 0.66627    | 0.66627    | 0.66627    |   0.0 |  0.19
Other   |            | 0.09939    |            |       |  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:      342384.0 ave      342384 max      342384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342384
Ave neighs/atom = 85.596000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.861408417825, Press = 0.333018778739653
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -17471.266   -17471.266   -17634.055   -17634.055    314.92539    314.92539    44013.731    44013.731    3797.8172    3797.8172 
   49000   -17479.345   -17479.345   -17639.657   -17639.657    310.13565    310.13565    44038.824    44038.824     2223.146     2223.146 
Loop time of 384.324 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.757 hours/ns, 2.602 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 383.34     | 383.34     | 383.34     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15055    | 0.15055    | 0.15055    |   0.0 |  0.04
Output  | 0.00017835 | 0.00017835 | 0.00017835 |   0.0 |  0.00
Modify  | 0.72956    | 0.72956    | 0.72956    |   0.0 |  0.19
Other   |            | 0.1018     |            |       |  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:      342322.0 ave      342322 max      342322 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342322
Ave neighs/atom = 85.580500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.832323806691, Press = -0.275059225412987
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -17479.345   -17479.345   -17639.657   -17639.657    310.13565    310.13565    44038.824    44038.824     2223.146     2223.146 
   50000   -17471.509   -17471.509   -17635.551   -17635.551    317.34974    317.34974    44076.061    44076.061    987.19417    987.19417 
Loop time of 379.752 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.487 hours/ns, 2.633 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    | 378.78     | 378.78     | 378.78     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14928    | 0.14928    | 0.14928    |   0.0 |  0.04
Output  | 0.00017733 | 0.00017733 | 0.00017733 |   0.0 |  0.00
Modify  | 0.72036    | 0.72036    | 0.72036    |   0.0 |  0.19
Other   |            | 0.1003     |            |       |  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:      342408.0 ave      342408 max      342408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342408
Ave neighs/atom = 85.602000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.814262755902, Press = -0.452164237312651
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -17471.509   -17471.509   -17635.551   -17635.551    317.34974    317.34974    44076.061    44076.061    987.19417    987.19417 
   51000   -17475.159   -17475.159   -17639.844   -17639.844    318.59522    318.59522      44080.5      44080.5     490.0258     490.0258 
Loop time of 408.688 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.524 hours/ns, 2.447 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    | 407.64     | 407.64     | 407.64     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1572     | 0.1572     | 0.1572     |   0.0 |  0.04
Output  | 0.00018663 | 0.00018663 | 0.00018663 |   0.0 |  0.00
Modify  | 0.78978    | 0.78978    | 0.78978    |   0.0 |  0.19
Other   |            | 0.1054     |            |       |  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:      342192.0 ave      342192 max      342192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342192
Ave neighs/atom = 85.548000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.853783648192, Press = -0.683629974976695
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -17475.159   -17475.159   -17639.844   -17639.844    318.59522    318.59522      44080.5      44080.5     490.0258     490.0258 
   52000    -17472.39    -17472.39   -17636.321   -17636.321    317.13606    317.13606    44102.122    44102.122   -116.59745   -116.59745 
Loop time of 398.86 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.217 ns/day, 110.794 hours/ns, 2.507 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    | 397.82     | 397.82     | 397.82     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15683    | 0.15683    | 0.15683    |   0.0 |  0.04
Output  | 0.0032564  | 0.0032564  | 0.0032564  |   0.0 |  0.00
Modify  | 0.77639    | 0.77639    | 0.77639    |   0.0 |  0.19
Other   |            | 0.1046     |            |       |  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:      342262.0 ave      342262 max      342262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342262
Ave neighs/atom = 85.565500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.864632903197, Press = -0.892184767373252
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000    -17472.39    -17472.39   -17636.321   -17636.321    317.13606    317.13606    44102.122    44102.122   -116.59745   -116.59745 
   53000   -17474.554   -17474.554   -17633.645   -17633.645     307.7731     307.7731    44106.205    44106.205    -96.74231    -96.74231 
Loop time of 382.279 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.188 hours/ns, 2.616 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    | 381.31     | 381.31     | 381.31     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15121    | 0.15121    | 0.15121    |   0.0 |  0.04
Output  | 0.00017745 | 0.00017745 | 0.00017745 |   0.0 |  0.00
Modify  | 0.71873    | 0.71873    | 0.71873    |   0.0 |  0.19
Other   |            | 0.09957    |            |       |  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:      342068.0 ave      342068 max      342068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342068
Ave neighs/atom = 85.517000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.838630392781, Press = -1.17425128182635
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -17474.554   -17474.554   -17633.645   -17633.645     307.7731     307.7731    44106.205    44106.205    -96.74231    -96.74231 
   54000   -17473.286   -17473.286    -17634.92    -17634.92    312.69066    312.69066    44149.288    44149.288   -2036.7778   -2036.7778 
Loop time of 414.367 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 115.102 hours/ns, 2.413 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    | 413.29     | 413.29     | 413.29     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16258    | 0.16258    | 0.16258    |   0.0 |  0.04
Output  | 0.00024753 | 0.00024753 | 0.00024753 |   0.0 |  0.00
Modify  | 0.80575    | 0.80575    | 0.80575    |   0.0 |  0.19
Other   |            | 0.1061     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      342086.0 ave      342086 max      342086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342086
Ave neighs/atom = 85.521500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.864356071502, Press = -1.82280453492325
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -17473.286   -17473.286    -17634.92    -17634.92    312.69066    312.69066    44149.288    44149.288   -2036.7778   -2036.7778 
   55000   -17467.224   -17467.224   -17631.122   -17631.122    317.07199    317.07199    44156.318    44156.318   -1918.4171   -1918.4171 
Loop time of 409.762 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.823 hours/ns, 2.440 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 408.7      | 408.7      | 408.7      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16116    | 0.16116    | 0.16116    |   0.0 |  0.04
Output  | 0.00017989 | 0.00017989 | 0.00017989 |   0.0 |  0.00
Modify  | 0.79842    | 0.79842    | 0.79842    |   0.0 |  0.19
Other   |            | 0.1039     |            |       |  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:      342050.0 ave      342050 max      342050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342050
Ave neighs/atom = 85.512500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.874539244918, Press = -0.76032927853907
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -17467.224   -17467.224   -17631.122   -17631.122    317.07199    317.07199    44156.318    44156.318   -1918.4171   -1918.4171 
   56000    -17475.65    -17475.65   -17635.578   -17635.578    309.39077    309.39077    44123.896    44123.896   -1166.2847   -1166.2847 
Loop time of 389.459 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.183 hours/ns, 2.568 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    | 388.45     | 388.45     | 388.45     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15322    | 0.15322    | 0.15322    |   0.0 |  0.04
Output  | 0.00017924 | 0.00017924 | 0.00017924 |   0.0 |  0.00
Modify  | 0.74871    | 0.74871    | 0.74871    |   0.0 |  0.19
Other   |            | 0.1023     |            |       |  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:      341948.0 ave      341948 max      341948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 341948
Ave neighs/atom = 85.487000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.91003967729, Press = -0.276417941849776
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000    -17475.65    -17475.65   -17635.578   -17635.578    309.39077    309.39077    44123.896    44123.896   -1166.2847   -1166.2847 
   57000   -17470.868   -17470.868   -17633.586   -17633.586    314.78792    314.78792    44125.232    44125.232    -903.0609    -903.0609 
Loop time of 402.909 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.214 ns/day, 111.919 hours/ns, 2.482 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    | 401.87     | 401.87     | 401.87     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15768    | 0.15768    | 0.15768    |   0.0 |  0.04
Output  | 0.00017627 | 0.00017627 | 0.00017627 |   0.0 |  0.00
Modify  | 0.77284    | 0.77284    | 0.77284    |   0.0 |  0.19
Other   |            | 0.103      |            |       |  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:      342028.0 ave      342028 max      342028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342028
Ave neighs/atom = 85.507000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.942749308995, Press = -0.0123407283484213
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -17470.868   -17470.868   -17633.586   -17633.586    314.78792    314.78792    44125.232    44125.232    -903.0609    -903.0609 
   58000   -17478.688   -17478.688   -17639.181   -17639.181    310.48333    310.48333    44114.942    44114.942   -992.71679   -992.71679 
Loop time of 386.969 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.491 hours/ns, 2.584 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    | 385.98     | 385.98     | 385.98     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15314    | 0.15314    | 0.15314    |   0.0 |  0.04
Output  | 0.00017697 | 0.00017697 | 0.00017697 |   0.0 |  0.00
Modify  | 0.73327    | 0.73327    | 0.73327    |   0.0 |  0.19
Other   |            | 0.1        |            |       |  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:      342012.0 ave      342012 max      342012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342012
Ave neighs/atom = 85.503000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.923417027196, Press = 0.12475977153743
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -17478.688   -17478.688   -17639.181   -17639.181    310.48333    310.48333    44114.942    44114.942   -992.71679   -992.71679 
   59000    -17472.38    -17472.38   -17632.501   -17632.501    309.76498    309.76498    44120.535    44120.535   -595.42284   -595.42284 
Loop time of 400.129 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 111.147 hours/ns, 2.499 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    | 399.09     | 399.09     | 399.09     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15721    | 0.15721    | 0.15721    |   0.0 |  0.04
Output  | 0.0001775  | 0.0001775  | 0.0001775  |   0.0 |  0.00
Modify  | 0.77715    | 0.77715    | 0.77715    |   0.0 |  0.19
Other   |            | 0.1033     |            |       |  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:      342076.0 ave      342076 max      342076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342076
Ave neighs/atom = 85.519000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.87954539757, Press = 0.49174396199601
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000    -17472.38    -17472.38   -17632.501   -17632.501    309.76498    309.76498    44120.535    44120.535   -595.42284   -595.42284 
   60000     -17473.3     -17473.3   -17633.183   -17633.183    309.30404    309.30404    44106.964    44106.964   -166.35117   -166.35117 
Loop time of 403.348 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.214 ns/day, 112.041 hours/ns, 2.479 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    | 402.3      | 402.3      | 402.3      |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1575     | 0.1575     | 0.1575     |   0.0 |  0.04
Output  | 0.00018282 | 0.00018282 | 0.00018282 |   0.0 |  0.00
Modify  | 0.78207    | 0.78207    | 0.78207    |   0.0 |  0.19
Other   |            | 0.1061     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        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:      341996.0 ave      341996 max      341996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 341996
Ave neighs/atom = 85.499000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.880895211501, Press = 0.970716794216234
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000     -17473.3     -17473.3   -17633.183   -17633.183    309.30404    309.30404    44106.964    44106.964   -166.35117   -166.35117 
   61000   -17474.038   -17474.038   -17635.643   -17635.643    312.63686    312.63686     44086.35     44086.35    592.06835    592.06835 
Loop time of 412.211 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.503 hours/ns, 2.426 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    | 411.14     | 411.14     | 411.14     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16044    | 0.16044    | 0.16044    |   0.0 |  0.04
Output  | 0.00018015 | 0.00018015 | 0.00018015 |   0.0 |  0.00
Modify  | 0.80889    | 0.80889    | 0.80889    |   0.0 |  0.20
Other   |            | 0.1059     |            |       |  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:      342028.0 ave      342028 max      342028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342028
Ave neighs/atom = 85.507000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.889978740486, Press = 0.902510520107077
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -17474.038   -17474.038   -17635.643   -17635.643    312.63686    312.63686     44086.35     44086.35    592.06835    592.06835 
   62000   -17472.922   -17472.922   -17633.129   -17633.129     309.9309     309.9309    44068.819    44068.819    1470.6902    1470.6902 
Loop time of 379.146 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.318 hours/ns, 2.638 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    | 378.18     | 378.18     | 378.18     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1499     | 0.1499     | 0.1499     |   0.0 |  0.04
Output  | 0.00024556 | 0.00024556 | 0.00024556 |   0.0 |  0.00
Modify  | 0.71488    | 0.71488    | 0.71488    |   0.0 |  0.19
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:        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:      342078.0 ave      342078 max      342078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342078
Ave neighs/atom = 85.519500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.927833836278, Press = 0.627878990845323
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -17472.922   -17472.922   -17633.129   -17633.129     309.9309     309.9309    44068.819    44068.819    1470.6902    1470.6902 
   63000   -17472.852   -17472.852   -17634.846   -17634.846    313.38806    313.38806    44069.615    44069.615    1364.2907    1364.2907 
Loop time of 402.166 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.215 ns/day, 111.713 hours/ns, 2.487 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    | 401.12     | 401.12     | 401.12     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15912    | 0.15912    | 0.15912    |   0.0 |  0.04
Output  | 0.00024879 | 0.00024879 | 0.00024879 |   0.0 |  0.00
Modify  | 0.78162    | 0.78162    | 0.78162    |   0.0 |  0.19
Other   |            | 0.1055     |            |       |  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:      342162.0 ave      342162 max      342162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342162
Ave neighs/atom = 85.540500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.946155304258, Press = 0.325504889326958
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 = 6.25
  ghost atom cutoff = 6.25
  binsize = 3.125, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.25
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -17472.852   -17472.852   -17634.846   -17634.846    313.38806    313.38806    44069.615    44069.615    1364.2907    1364.2907 
   64000   -17477.477   -17477.477   -17636.231   -17636.231    307.12143    307.12143    44071.566    44071.566     1050.967     1050.967 
Loop time of 408.628 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.211 ns/day, 113.508 hours/ns, 2.447 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 407.56     | 407.56     | 407.56     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15948    | 0.15948    | 0.15948    |   0.0 |  0.04
Output  | 0.00017661 | 0.00017661 | 0.00017661 |   0.0 |  0.00
Modify  | 0.80249    | 0.80249    | 0.80249    |   0.0 |  0.20
Other   |            | 0.1078     |            |       |  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:      342162.0 ave      342162 max      342162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0