# 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 2.851000025868416*${_u_distance}
variable latticeconst_converted equal 2.851000025868416*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.85100002586842
Lattice spacing in x,y,z = 2.8510000 2.8510000 2.8510000
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 (28.510000 28.510000 28.510000)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (28.510000 28.510000 28.510000)
  create_atoms CPU = 0.004 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_EtesamiAsadi_2018_Fe__MO_549900287421_001
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_549900287421_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -8514.5882   -8514.5882   -8579.9999   -8579.9999       253.15       253.15    23173.502    23173.502    3014.9739    3014.9739 
    1000   -8445.8864   -8445.8864   -8510.6413   -8510.6413      250.608      250.608    23391.451    23391.451   -2872.3947   -2872.3947 
Loop time of 123.234 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.701 ns/day, 34.232 hours/ns, 8.115 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    | 122.7      | 122.7      | 122.7      |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10107    | 0.10107    | 0.10107    |   0.0 |  0.08
Output  | 0.00019514 | 0.00019514 | 0.00019514 |   0.0 |  0.00
Modify  | 0.37171    | 0.37171    | 0.37171    |   0.0 |  0.30
Other   |            | 0.0615     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -8445.8864   -8445.8864   -8510.6413   -8510.6413      250.608      250.608    23391.451    23391.451   -2872.3947   -2872.3947 
    2000   -8446.2009   -8446.2009    -8511.519    -8511.519    252.78797    252.78797    23341.463    23341.463    850.46394    850.46394 
Loop time of 119.841 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.721 ns/day, 33.289 hours/ns, 8.344 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    | 119.35     | 119.35     | 119.35     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095936   | 0.095936   | 0.095936   |   0.0 |  0.08
Output  | 0.0001893  | 0.0001893  | 0.0001893  |   0.0 |  0.00
Modify  | 0.3335     | 0.3335     | 0.3335     |   0.0 |  0.28
Other   |            | 0.05883    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128088.0 ave      128088 max      128088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128088
Ave neighs/atom = 64.044000
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -8446.2009   -8446.2009    -8511.519    -8511.519    252.78797    252.78797    23341.463    23341.463    850.46394    850.46394 
    3000   -8447.5123   -8447.5123   -8508.4279   -8508.4279    235.74932    235.74932    23344.805    23344.805    772.27522    772.27522 
Loop time of 119.645 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.722 ns/day, 33.235 hours/ns, 8.358 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    | 119.16     | 119.16     | 119.16     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094804   | 0.094804   | 0.094804   |   0.0 |  0.08
Output  | 0.0001949  | 0.0001949  | 0.0001949  |   0.0 |  0.00
Modify  | 0.33376    | 0.33376    | 0.33376    |   0.0 |  0.28
Other   |            | 0.05899    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128150.0 ave      128150 max      128150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128150
Ave neighs/atom = 64.075000
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8447.5123   -8447.5123   -8508.4279   -8508.4279    235.74932    235.74932    23344.805    23344.805    772.27522    772.27522 
    4000   -8445.6178   -8445.6178   -8510.4198   -8510.4198    250.79024    250.79024    23340.425    23340.425    952.92416    952.92416 
Loop time of 120.366 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.718 ns/day, 33.435 hours/ns, 8.308 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    | 119.88     | 119.88     | 119.88     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095968   | 0.095968   | 0.095968   |   0.0 |  0.08
Output  | 0.00019209 | 0.00019209 | 0.00019209 |   0.0 |  0.00
Modify  | 0.33506    | 0.33506    | 0.33506    |   0.0 |  0.28
Other   |            | 0.05919    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128150.0 ave      128150 max      128150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128150
Ave neighs/atom = 64.075000
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -8445.6178   -8445.6178   -8510.4198   -8510.4198    250.79024    250.79024    23340.425    23340.425    952.92416    952.92416 
    5000   -8447.8692   -8447.8692   -8509.9023   -8509.9023     240.0744     240.0744    23349.255    23349.255    348.78165    348.78165 
Loop time of 130.911 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.660 ns/day, 36.364 hours/ns, 7.639 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    | 130.37     | 130.37     | 130.37     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10202    | 0.10202    | 0.10202    |   0.0 |  0.08
Output  | 0.00015288 | 0.00015288 | 0.00015288 |   0.0 |  0.00
Modify  | 0.37994    | 0.37994    | 0.37994    |   0.0 |  0.29
Other   |            | 0.06244    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128110.0 ave      128110 max      128110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128110
Ave neighs/atom = 64.055000
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 = 251.461386016861, Press = -811.428309106448
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8447.8692   -8447.8692   -8509.9023   -8509.9023     240.0744     240.0744    23349.255    23349.255    348.78165    348.78165 
    6000   -8444.2546   -8444.2546   -8510.7771   -8510.7771    257.44888    257.44888    23365.609    23365.609   -870.18379   -870.18379 
Loop time of 119.761 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.721 ns/day, 33.267 hours/ns, 8.350 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    | 119.26     | 119.26     | 119.26     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095745   | 0.095745   | 0.095745   |   0.0 |  0.08
Output  | 0.00015523 | 0.00015523 | 0.00015523 |   0.0 |  0.00
Modify  | 0.35016    | 0.35016    | 0.35016    |   0.0 |  0.29
Other   |            | 0.05884    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128162.0 ave      128162 max      128162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128162
Ave neighs/atom = 64.081000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.23241286814, Press = 45.4990627125214
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8444.2546   -8444.2546   -8510.7771   -8510.7771    257.44888    257.44888    23365.609    23365.609   -870.18379   -870.18379 
    7000   -8446.5224   -8446.5224   -8513.1536   -8513.1536    257.86978    257.86978    23327.805    23327.805    1498.9632    1498.9632 
Loop time of 119.644 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.722 ns/day, 33.234 hours/ns, 8.358 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    | 119.14     | 119.14     | 119.14     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095339   | 0.095339   | 0.095339   |   0.0 |  0.08
Output  | 0.00015531 | 0.00015531 | 0.00015531 |   0.0 |  0.00
Modify  | 0.35189    | 0.35189    | 0.35189    |   0.0 |  0.29
Other   |            | 0.05851    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128124.0 ave      128124 max      128124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128124
Ave neighs/atom = 64.062000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.78754593453, Press = -39.8020824613256
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8446.5224   -8446.5224   -8513.1536   -8513.1536    257.86978    257.86978    23327.805    23327.805    1498.9632    1498.9632 
    8000   -8445.1168   -8445.1168    -8511.424    -8511.424     256.6157     256.6157     23364.32     23364.32   -888.26759   -888.26759 
Loop time of 120.801 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.715 ns/day, 33.556 hours/ns, 8.278 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    | 120.29     | 120.29     | 120.29     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096156   | 0.096156   | 0.096156   |   0.0 |  0.08
Output  | 0.00015272 | 0.00015272 | 0.00015272 |   0.0 |  0.00
Modify  | 0.35653    | 0.35653    | 0.35653    |   0.0 |  0.30
Other   |            | 0.05829    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128102.0 ave      128102 max      128102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128102
Ave neighs/atom = 64.051000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.444868547532, Press = -3.00100933771206
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8445.1168   -8445.1168    -8511.424    -8511.424     256.6157     256.6157     23364.32     23364.32   -888.26759   -888.26759 
    9000    -8448.586    -8448.586   -8512.4551   -8512.4551    247.18008    247.18008     23342.76     23342.76    449.92908    449.92908 
Loop time of 136.215 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.634 ns/day, 37.838 hours/ns, 7.341 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    | 135.62     | 135.62     | 135.62     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10615    | 0.10615    | 0.10615    |   0.0 |  0.08
Output  | 0.00015463 | 0.00015463 | 0.00015463 |   0.0 |  0.00
Modify  | 0.42459    | 0.42459    | 0.42459    |   0.0 |  0.31
Other   |            | 0.06506    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128116.0 ave      128116 max      128116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128116
Ave neighs/atom = 64.058000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.551786014839, Press = -8.23610220304157
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000    -8448.586    -8448.586   -8512.4551   -8512.4551    247.18008    247.18008     23342.76     23342.76    449.92908    449.92908 
   10000   -8444.7126   -8444.7126   -8513.5478   -8513.5478    266.39937    266.39937    23348.755    23348.755    215.90339    215.90339 
Loop time of 119.326 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.146 hours/ns, 8.380 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    | 118.82     | 118.82     | 118.82     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095544   | 0.095544   | 0.095544   |   0.0 |  0.08
Output  | 0.00015553 | 0.00015553 | 0.00015553 |   0.0 |  0.00
Modify  | 0.35027    | 0.35027    | 0.35027    |   0.0 |  0.29
Other   |            | 0.05843    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128088.0 ave      128088 max      128088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128088
Ave neighs/atom = 64.044000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.495183546101, Press = -5.0647041535329
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8444.7126   -8444.7126   -8513.5478   -8513.5478    266.39937    266.39937    23348.755    23348.755    215.90339    215.90339 
   11000   -8446.8116   -8446.8116   -8512.1803   -8512.1803    252.98379    252.98379    23337.807    23337.807    948.91719    948.91719 
Loop time of 119.958 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.720 ns/day, 33.322 hours/ns, 8.336 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.45     | 119.45     | 119.45     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096875   | 0.096875   | 0.096875   |   0.0 |  0.08
Output  | 0.00015542 | 0.00015542 | 0.00015542 |   0.0 |  0.00
Modify  | 0.35318    | 0.35318    | 0.35318    |   0.0 |  0.29
Other   |            | 0.05847    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128088.0 ave      128088 max      128088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128088
Ave neighs/atom = 64.044000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.699006899777, Press = -8.84768516729546
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8446.8116   -8446.8116   -8512.1803   -8512.1803    252.98379    252.98379    23337.807    23337.807    948.91719    948.91719 
   12000   -8449.2305   -8449.2305   -8512.1722   -8512.1722    243.59072    243.59072     23377.88     23377.88   -2133.6507   -2133.6507 
Loop time of 120.238 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.719 ns/day, 33.400 hours/ns, 8.317 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    | 119.73     | 119.73     | 119.73     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097973   | 0.097973   | 0.097973   |   0.0 |  0.08
Output  | 0.00015926 | 0.00015926 | 0.00015926 |   0.0 |  0.00
Modify  | 0.3558     | 0.3558     | 0.3558     |   0.0 |  0.30
Other   |            | 0.05837    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128102.0 ave      128102 max      128102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128102
Ave neighs/atom = 64.051000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.886177912747, Press = 1.74473128982708
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8449.2305   -8449.2305   -8512.1722   -8512.1722    243.59072    243.59072     23377.88     23377.88   -2133.6507   -2133.6507 
   13000   -8445.8014   -8445.8014   -8512.1688   -8512.1688    256.84887    256.84887    23320.945    23320.945    2179.2484    2179.2484 
Loop time of 124.528 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.694 ns/day, 34.591 hours/ns, 8.030 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    | 123.99     | 123.99     | 123.99     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10064    | 0.10064    | 0.10064    |   0.0 |  0.08
Output  | 0.00015596 | 0.00015596 | 0.00015596 |   0.0 |  0.00
Modify  | 0.37474    | 0.37474    | 0.37474    |   0.0 |  0.30
Other   |            | 0.06009    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128084.0 ave      128084 max      128084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128084
Ave neighs/atom = 64.042000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.773626782295, Press = -8.36858524536006
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8445.8014   -8445.8014   -8512.1688   -8512.1688    256.84887    256.84887    23320.945    23320.945    2179.2484    2179.2484 
   14000    -8448.353    -8448.353   -8512.8374   -8512.8374    249.56112    249.56112    23365.412    23365.412   -1242.5382   -1242.5382 
Loop time of 138.659 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.623 ns/day, 38.516 hours/ns, 7.212 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    | 138.05     | 138.05     | 138.05     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10718    | 0.10718    | 0.10718    |   0.0 |  0.08
Output  | 0.00019943 | 0.00019943 | 0.00019943 |   0.0 |  0.00
Modify  | 0.43237    | 0.43237    | 0.43237    |   0.0 |  0.31
Other   |            | 0.06587    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128128.0 ave      128128 max      128128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128128
Ave neighs/atom = 64.064000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.543016154644, Press = -1.81469638051835
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000    -8448.353    -8448.353   -8512.8374   -8512.8374    249.56112    249.56112    23365.412    23365.412   -1242.5382   -1242.5382 
   15000    -8447.519    -8447.519   -8512.4318   -8512.4318    251.21901    251.21901     23335.87     23335.87    946.62795    946.62795 
Loop time of 132.31 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.653 ns/day, 36.753 hours/ns, 7.558 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    | 131.73     | 131.73     | 131.73     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10513    | 0.10513    | 0.10513    |   0.0 |  0.08
Output  | 0.00015476 | 0.00015476 | 0.00015476 |   0.0 |  0.00
Modify  | 0.41058    | 0.41058    | 0.41058    |   0.0 |  0.31
Other   |            | 0.06241    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128102.0 ave      128102 max      128102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128102
Ave neighs/atom = 64.051000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.524472197644, Press = -2.22143614297073
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000    -8447.519    -8447.519   -8512.4318   -8512.4318    251.21901    251.21901     23335.87     23335.87    946.62795    946.62795 
   16000   -8443.6502   -8443.6502   -8510.0911   -8510.0911    257.13304    257.13304    23359.945    23359.945   -364.39784   -364.39784 
Loop time of 137.92 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.626 ns/day, 38.311 hours/ns, 7.251 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    | 137.32     | 137.32     | 137.32     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10806    | 0.10806    | 0.10806    |   0.0 |  0.08
Output  | 0.00025519 | 0.00025519 | 0.00025519 |   0.0 |  0.00
Modify  | 0.42937    | 0.42937    | 0.42937    |   0.0 |  0.31
Other   |            | 0.06475    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128122.0 ave      128122 max      128122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128122
Ave neighs/atom = 64.061000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.523404733717, Press = -4.34128651639636
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8443.6502   -8443.6502   -8510.0911   -8510.0911    257.13304    257.13304    23359.945    23359.945   -364.39784   -364.39784 
   17000   -8447.0483   -8447.0483   -8512.2281   -8512.2281    252.25227    252.25227    23351.274    23351.274   -57.765857   -57.765857 
Loop time of 123.719 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.698 ns/day, 34.366 hours/ns, 8.083 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    | 123.19     | 123.19     | 123.19     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098797   | 0.098797   | 0.098797   |   0.0 |  0.08
Output  | 0.00018979 | 0.00018979 | 0.00018979 |   0.0 |  0.00
Modify  | 0.37176    | 0.37176    | 0.37176    |   0.0 |  0.30
Other   |            | 0.05956    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128122.0 ave      128122 max      128122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128122
Ave neighs/atom = 64.061000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.665606910452, Press = -0.946854858327776
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8447.0483   -8447.0483   -8512.2281   -8512.2281    252.25227    252.25227    23351.274    23351.274   -57.765857   -57.765857 
   18000   -8444.4386   -8444.4386   -8511.7115   -8511.7115    260.35285    260.35285    23348.793    23348.793    306.00389    306.00389 
Loop time of 120.277 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.718 ns/day, 33.410 hours/ns, 8.314 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    | 119.77     | 119.77     | 119.77     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096286   | 0.096286   | 0.096286   |   0.0 |  0.08
Output  | 0.00015521 | 0.00015521 | 0.00015521 |   0.0 |  0.00
Modify  | 0.35348    | 0.35348    | 0.35348    |   0.0 |  0.29
Other   |            | 0.05843    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128118.0 ave      128118 max      128118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128118
Ave neighs/atom = 64.059000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.812385025193, Press = -4.38203701942676
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8444.4386   -8444.4386   -8511.7115   -8511.7115    260.35285    260.35285    23348.793    23348.793    306.00389    306.00389 
   19000   -8450.4343   -8450.4343   -8513.6581   -8513.6581     244.6827     244.6827    23360.551    23360.551   -1070.8542   -1070.8542 
Loop time of 126.003 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.686 ns/day, 35.001 hours/ns, 7.936 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    | 125.46     | 125.46     | 125.46     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099151   | 0.099151   | 0.099151   |   0.0 |  0.08
Output  | 0.00015426 | 0.00015426 | 0.00015426 |   0.0 |  0.00
Modify  | 0.37853    | 0.37853    | 0.37853    |   0.0 |  0.30
Other   |            | 0.06051    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128104.0 ave      128104 max      128104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128104
Ave neighs/atom = 64.052000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.779103253512, Press = 2.21778834129793
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8450.4343   -8450.4343   -8513.6581   -8513.6581     244.6827     244.6827    23360.551    23360.551   -1070.8542   -1070.8542 
   20000   -8446.0389   -8446.0389   -8510.4908   -8510.4908    249.43576    249.43576    23316.711    23316.711    2706.2926    2706.2926 
Loop time of 120.144 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.719 ns/day, 33.373 hours/ns, 8.323 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.63     | 119.63     | 119.63     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096503   | 0.096503   | 0.096503   |   0.0 |  0.08
Output  | 0.00015377 | 0.00015377 | 0.00015377 |   0.0 |  0.00
Modify  | 0.35463    | 0.35463    | 0.35463    |   0.0 |  0.30
Other   |            | 0.0589     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128104.0 ave      128104 max      128104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128104
Ave neighs/atom = 64.052000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.697253728235, Press = -6.51212175246684
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8446.0389   -8446.0389   -8510.4908   -8510.4908    249.43576    249.43576    23316.711    23316.711    2706.2926    2706.2926 
   21000   -8449.3653   -8449.3653   -8512.6431   -8512.6431    244.89174    244.89174    23376.299    23376.299   -2010.4245   -2010.4245 
Loop time of 119.419 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.172 hours/ns, 8.374 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    | 118.91     | 118.91     | 118.91     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095189   | 0.095189   | 0.095189   |   0.0 |  0.08
Output  | 0.00015604 | 0.00015604 | 0.00015604 |   0.0 |  0.00
Modify  | 0.35107    | 0.35107    | 0.35107    |   0.0 |  0.29
Other   |            | 0.05977    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128118.0 ave      128118 max      128118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128118
Ave neighs/atom = 64.059000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.601840845604, Press = 0.646702299849891
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8449.3653   -8449.3653   -8512.6431   -8512.6431    244.89174    244.89174    23376.299    23376.299   -2010.4245   -2010.4245 
   22000   -8447.7755   -8447.7755   -8513.5464   -8513.5464    254.53994    254.53994    23324.186    23324.186    1698.6307    1698.6307 
Loop time of 127.44 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.678 ns/day, 35.400 hours/ns, 7.847 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    | 126.89     | 126.89     | 126.89     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10107    | 0.10107    | 0.10107    |   0.0 |  0.08
Output  | 0.00015373 | 0.00015373 | 0.00015373 |   0.0 |  0.00
Modify  | 0.38528    | 0.38528    | 0.38528    |   0.0 |  0.30
Other   |            | 0.06168    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128118.0 ave      128118 max      128118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128118
Ave neighs/atom = 64.059000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.659208603639, Press = -3.23216945631928
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8447.7755   -8447.7755   -8513.5464   -8513.5464    254.53994    254.53994    23324.186    23324.186    1698.6307    1698.6307 
   23000   -8442.8612   -8442.8612   -8509.8266   -8509.8266    259.16313    259.16313    23378.091    23378.091    -1530.338    -1530.338 
Loop time of 119.026 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.063 hours/ns, 8.402 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    | 118.52     | 118.52     | 118.52     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095276   | 0.095276   | 0.095276   |   0.0 |  0.08
Output  | 0.00015254 | 0.00015254 | 0.00015254 |   0.0 |  0.00
Modify  | 0.35013    | 0.35013    | 0.35013    |   0.0 |  0.29
Other   |            | 0.05901    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128142.0 ave      128142 max      128142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128142
Ave neighs/atom = 64.071000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.764317480464, Press = -1.67721393817072
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8442.8612   -8442.8612   -8509.8266   -8509.8266    259.16313    259.16313    23378.091    23378.091    -1530.338    -1530.338 
   24000   -8447.6672   -8447.6672   -8511.7474   -8511.7474    247.99685    247.99685    23333.644    23333.644    1258.7355    1258.7355 
Loop time of 119.012 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.059 hours/ns, 8.402 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    | 118.51     | 118.51     | 118.51     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095179   | 0.095179   | 0.095179   |   0.0 |  0.08
Output  | 0.00015154 | 0.00015154 | 0.00015154 |   0.0 |  0.00
Modify  | 0.35015    | 0.35015    | 0.35015    |   0.0 |  0.29
Other   |            | 0.05814    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128098.0 ave      128098 max      128098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128098
Ave neighs/atom = 64.049000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.85812820169, Press = -1.1490395826561
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8447.6672   -8447.6672   -8511.7474   -8511.7474    247.99685    247.99685    23333.644    23333.644    1258.7355    1258.7355 
   25000   -8445.5291   -8445.5291   -8511.4446   -8511.4446    255.09975    255.09975    23372.889    23372.889   -1451.3223   -1451.3223 
Loop time of 118.937 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.038 hours/ns, 8.408 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.43     | 118.43     | 118.43     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095046   | 0.095046   | 0.095046   |   0.0 |  0.08
Output  | 0.00015252 | 0.00015252 | 0.00015252 |   0.0 |  0.00
Modify  | 0.35019    | 0.35019    | 0.35019    |   0.0 |  0.29
Other   |            | 0.05812    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128112.0 ave      128112 max      128112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128112
Ave neighs/atom = 64.056000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.958683657385, Press = -2.23764949355563
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8445.5291   -8445.5291   -8511.4446   -8511.4446    255.09975    255.09975    23372.889    23372.889   -1451.3223   -1451.3223 
   26000   -8446.2753   -8446.2753   -8511.7897   -8511.7897    253.54728    253.54728    23332.294    23332.294    1398.0413    1398.0413 
Loop time of 119.832 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.721 ns/day, 33.287 hours/ns, 8.345 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    | 119.32     | 119.32     | 119.32     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096804   | 0.096804   | 0.096804   |   0.0 |  0.08
Output  | 0.00015558 | 0.00015558 | 0.00015558 |   0.0 |  0.00
Modify  | 0.35448    | 0.35448    | 0.35448    |   0.0 |  0.30
Other   |            | 0.0581     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128108.0 ave      128108 max      128108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128108
Ave neighs/atom = 64.054000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.908081629608, Press = -0.595352516380531
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -8446.2753   -8446.2753   -8511.7897   -8511.7897    253.54728    253.54728    23332.294    23332.294    1398.0413    1398.0413 
   27000   -8449.8517   -8449.8517   -8513.4355   -8513.4355    246.07585    246.07585    23374.568    23374.568   -2002.4865   -2002.4865 
Loop time of 119.409 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.169 hours/ns, 8.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    | 118.9      | 118.9      | 118.9      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096551   | 0.096551   | 0.096551   |   0.0 |  0.08
Output  | 0.00015326 | 0.00015326 | 0.00015326 |   0.0 |  0.00
Modify  | 0.35129    | 0.35129    | 0.35129    |   0.0 |  0.29
Other   |            | 0.05756    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128126.0 ave      128126 max      128126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128126
Ave neighs/atom = 64.063000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.894034717001, Press = -3.47201810309657
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8449.8517   -8449.8517   -8513.4355   -8513.4355    246.07585    246.07585    23374.568    23374.568   -2002.4865   -2002.4865 
   28000   -8446.4178   -8446.4178    -8511.236    -8511.236    250.85304    250.85304    23328.318    23328.318    1745.4761    1745.4761 
Loop time of 121.664 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.710 ns/day, 33.796 hours/ns, 8.219 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.15     | 121.15     | 121.15     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09733    | 0.09733    | 0.09733    |   0.0 |  0.08
Output  | 0.00015224 | 0.00015224 | 0.00015224 |   0.0 |  0.00
Modify  | 0.36035    | 0.36035    | 0.36035    |   0.0 |  0.30
Other   |            | 0.05833    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128106.0 ave      128106 max      128106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128106
Ave neighs/atom = 64.053000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.844174029673, Press = 1.2982299512759
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8446.4178   -8446.4178    -8511.236    -8511.236    250.85304    250.85304    23328.318    23328.318    1745.4761    1745.4761 
   29000   -8446.5711   -8446.5711   -8509.8209   -8509.8209    244.78326    244.78326    23360.802    23360.802   -474.82948   -474.82948 
Loop time of 139.489 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.619 ns/day, 38.747 hours/ns, 7.169 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    | 138.88     | 138.88     | 138.88     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10779    | 0.10779    | 0.10779    |   0.0 |  0.08
Output  | 0.00019024 | 0.00019024 | 0.00019024 |   0.0 |  0.00
Modify  | 0.43476    | 0.43476    | 0.43476    |   0.0 |  0.31
Other   |            | 0.06439    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128128.0 ave      128128 max      128128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128128
Ave neighs/atom = 64.064000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.832356093045, Press = -3.62033054530324
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8446.5711   -8446.5711   -8509.8209   -8509.8209    244.78326    244.78326    23360.802    23360.802   -474.82948   -474.82948 
   30000   -8446.5853   -8446.5853   -8510.3942   -8510.3942    246.94737    246.94737    23354.361    23354.361   -62.288613   -62.288613 
Loop time of 140.276 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.616 ns/day, 38.966 hours/ns, 7.129 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    | 139.66     | 139.66     | 139.66     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10863    | 0.10863    | 0.10863    |   0.0 |  0.08
Output  | 0.00045727 | 0.00045727 | 0.00045727 |   0.0 |  0.00
Modify  | 0.43711    | 0.43711    | 0.43711    |   0.0 |  0.31
Other   |            | 0.06516    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128098.0 ave      128098 max      128098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128098
Ave neighs/atom = 64.049000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.868635195796, Press = 0.323286240217179
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8446.5853   -8446.5853   -8510.3942   -8510.3942    246.94737    246.94737    23354.361    23354.361   -62.288613   -62.288613 
   31000   -8448.3381   -8448.3381   -8512.9443   -8512.9443    250.03273    250.03273    23340.837    23340.837    494.25135    494.25135 
Loop time of 126.373 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.684 ns/day, 35.104 hours/ns, 7.913 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    | 125.83     | 125.83     | 125.83     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1004     | 0.1004     | 0.1004     |   0.0 |  0.08
Output  | 0.00015187 | 0.00015187 | 0.00015187 |   0.0 |  0.00
Modify  | 0.38124    | 0.38124    | 0.38124    |   0.0 |  0.30
Other   |            | 0.06051    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128120.0 ave      128120 max      128120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128120
Ave neighs/atom = 64.060000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.793482758209, Press = -2.30140271783526
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8448.3381   -8448.3381   -8512.9443   -8512.9443    250.03273    250.03273    23340.837    23340.837    494.25135    494.25135 
   32000   -8446.0087   -8446.0087   -8514.1833   -8514.1833    263.84258    263.84258    23364.176    23364.176    -1172.396    -1172.396 
Loop time of 130.553 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.662 ns/day, 36.265 hours/ns, 7.660 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    | 129.99     | 129.99     | 129.99     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10235    | 0.10235    | 0.10235    |   0.0 |  0.08
Output  | 0.00015573 | 0.00015573 | 0.00015573 |   0.0 |  0.00
Modify  | 0.3965     | 0.3965     | 0.3965     |   0.0 |  0.30
Other   |            | 0.06178    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128096.0 ave      128096 max      128096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128096
Ave neighs/atom = 64.048000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.797461426594, Press = -0.514879059547068
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -8446.0087   -8446.0087   -8514.1833   -8514.1833    263.84258    263.84258    23364.176    23364.176    -1172.396    -1172.396 
   33000   -8447.1687   -8447.1687   -8511.9975   -8511.9975     250.8944     250.8944    23337.643    23337.643    938.16798    938.16798 
Loop time of 119.106 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.085 hours/ns, 8.396 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    | 118.6      | 118.6      | 118.6      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095161   | 0.095161   | 0.095161   |   0.0 |  0.08
Output  | 0.00018945 | 0.00018945 | 0.00018945 |   0.0 |  0.00
Modify  | 0.34972    | 0.34972    | 0.34972    |   0.0 |  0.29
Other   |            | 0.05754    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128074.0 ave      128074 max      128074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128074
Ave neighs/atom = 64.037000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.806504349331, Press = -2.01312379089285
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -8447.1687   -8447.1687   -8511.9975   -8511.9975     250.8944     250.8944    23337.643    23337.643    938.16798    938.16798 
   34000    -8444.361    -8444.361    -8510.171    -8510.171    254.69136    254.69136    23384.835    23384.835   -2146.9694   -2146.9694 
Loop time of 119.69 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.722 ns/day, 33.247 hours/ns, 8.355 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    | 119.19     | 119.19     | 119.19     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095528   | 0.095528   | 0.095528   |   0.0 |  0.08
Output  | 0.00015472 | 0.00015472 | 0.00015472 |   0.0 |  0.00
Modify  | 0.35011    | 0.35011    | 0.35011    |   0.0 |  0.29
Other   |            | 0.05781    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128124.0 ave      128124 max      128124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128124
Ave neighs/atom = 64.062000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.885623186693, Press = -0.623338182776251
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000    -8444.361    -8444.361    -8510.171    -8510.171    254.69136    254.69136    23384.835    23384.835   -2146.9694   -2146.9694 
   35000   -8448.2634   -8448.2634   -8513.2754   -8513.2754    251.60319    251.60319    23289.304    23289.304    4302.7666    4302.7666 
Loop time of 119.397 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.166 hours/ns, 8.375 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    | 118.89     | 118.89     | 118.89     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096238   | 0.096238   | 0.096238   |   0.0 |  0.08
Output  | 0.00015207 | 0.00015207 | 0.00015207 |   0.0 |  0.00
Modify  | 0.35003    | 0.35003    | 0.35003    |   0.0 |  0.29
Other   |            | 0.05765    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128096.0 ave      128096 max      128096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128096
Ave neighs/atom = 64.048000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.899990225513, Press = -1.20606677242501
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8448.2634   -8448.2634   -8513.2754   -8513.2754    251.60319    251.60319    23289.304    23289.304    4302.7666    4302.7666 
   36000   -8445.4848   -8445.4848   -8511.4098   -8511.4098    255.13645    255.13645    23391.993    23391.993   -2833.7594   -2833.7594 
Loop time of 119.539 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.205 hours/ns, 8.365 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    | 119.03     | 119.03     | 119.03     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096926   | 0.096926   | 0.096926   |   0.0 |  0.08
Output  | 0.00015414 | 0.00015414 | 0.00015414 |   0.0 |  0.00
Modify  | 0.35235    | 0.35235    | 0.35235    |   0.0 |  0.29
Other   |            | 0.05817    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128126.0 ave      128126 max      128126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128126
Ave neighs/atom = 64.063000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.869149407229, Press = -1.38365154584592
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -8445.4848   -8445.4848   -8511.4098   -8511.4098    255.13645    255.13645    23391.993    23391.993   -2833.7594   -2833.7594 
   37000   -8446.5321   -8446.5321   -8513.6916   -8513.6916    259.91447    259.91447    23321.663    23321.663    2022.9089    2022.9089 
Loop time of 119.833 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.721 ns/day, 33.287 hours/ns, 8.345 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    | 119.32     | 119.32     | 119.32     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096886   | 0.096886   | 0.096886   |   0.0 |  0.08
Output  | 0.00015565 | 0.00015565 | 0.00015565 |   0.0 |  0.00
Modify  | 0.35495    | 0.35495    | 0.35495    |   0.0 |  0.30
Other   |            | 0.05873    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128092.0 ave      128092 max      128092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128092
Ave neighs/atom = 64.046000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.922202042409, Press = -0.734728659628933
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -8446.5321   -8446.5321   -8513.6916   -8513.6916    259.91447    259.91447    23321.663    23321.663    2022.9089    2022.9089 
   38000    -8445.176    -8445.176   -8509.3325   -8509.3325    248.29219    248.29219    23363.779    23363.779   -617.86827   -617.86827 
Loop time of 123.247 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.701 ns/day, 34.235 hours/ns, 8.114 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    | 122.72     | 122.72     | 122.72     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099444   | 0.099444   | 0.099444   |   0.0 |  0.08
Output  | 0.00019624 | 0.00019624 | 0.00019624 |   0.0 |  0.00
Modify  | 0.36964    | 0.36964    | 0.36964    |   0.0 |  0.30
Other   |            | 0.05964    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128114.0 ave      128114 max      128114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128114
Ave neighs/atom = 64.057000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.912347266078, Press = -2.03034897251813
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000    -8445.176    -8445.176   -8509.3325   -8509.3325    248.29219    248.29219    23363.779    23363.779   -617.86827   -617.86827 
   39000   -8449.2123   -8449.2123   -8513.4459   -8513.4459    248.59048    248.59048    23345.323    23345.323    221.47321    221.47321 
Loop time of 119.711 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.722 ns/day, 33.253 hours/ns, 8.353 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    | 119.2      | 119.2      | 119.2      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096477   | 0.096477   | 0.096477   |   0.0 |  0.08
Output  | 0.00015622 | 0.00015622 | 0.00015622 |   0.0 |  0.00
Modify  | 0.35212    | 0.35212    | 0.35212    |   0.0 |  0.29
Other   |            | 0.05846    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128094.0 ave      128094 max      128094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128094
Ave neighs/atom = 64.047000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.861003140258, Press = 0.498549982730558
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8449.2123   -8449.2123   -8513.4459   -8513.4459    248.59048    248.59048    23345.323    23345.323    221.47321    221.47321 
   40000   -8447.7807   -8447.7807   -8512.5615   -8512.5615    250.70858    250.70858    23342.209    23342.209    492.34593    492.34593 
Loop time of 127.741 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.676 ns/day, 35.484 hours/ns, 7.828 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    | 127.19     | 127.19     | 127.19     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10261    | 0.10261    | 0.10261    |   0.0 |  0.08
Output  | 0.0001525  | 0.0001525  | 0.0001525  |   0.0 |  0.00
Modify  | 0.38532    | 0.38532    | 0.38532    |   0.0 |  0.30
Other   |            | 0.0614     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128106.0 ave      128106 max      128106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128106
Ave neighs/atom = 64.053000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.85380066181, Press = -3.53793652218429
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -8447.7807   -8447.7807   -8512.5615   -8512.5615    250.70858    250.70858    23342.209    23342.209    492.34593    492.34593 
   41000   -8442.2056   -8442.2056   -8509.9412   -8509.9412    262.14358    262.14358    23390.486    23390.486   -2399.8261   -2399.8261 
Loop time of 119.698 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.722 ns/day, 33.249 hours/ns, 8.354 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    | 119.19     | 119.19     | 119.19     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095931   | 0.095931   | 0.095931   |   0.0 |  0.08
Output  | 0.00018925 | 0.00018925 | 0.00018925 |   0.0 |  0.00
Modify  | 0.35179    | 0.35179    | 0.35179    |   0.0 |  0.29
Other   |            | 0.05872    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128110.0 ave      128110 max      128110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128110
Ave neighs/atom = 64.055000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.883540253558, Press = 2.08728274682773
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -8442.2056   -8442.2056   -8509.9412   -8509.9412    262.14358    262.14358    23390.486    23390.486   -2399.8261   -2399.8261 
   42000   -8447.1049   -8447.1049    -8510.546    -8510.546    245.52371    245.52371    23331.793    23331.793    1578.3662    1578.3662 
Loop time of 120.788 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.715 ns/day, 33.552 hours/ns, 8.279 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    | 120.28     | 120.28     | 120.28     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096469   | 0.096469   | 0.096469   |   0.0 |  0.08
Output  | 0.00015524 | 0.00015524 | 0.00015524 |   0.0 |  0.00
Modify  | 0.35362    | 0.35362    | 0.35362    |   0.0 |  0.29
Other   |            | 0.0591     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128120.0 ave      128120 max      128120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128120
Ave neighs/atom = 64.060000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.950791745427, Press = -1.22081481111384
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -8447.1049   -8447.1049    -8510.546    -8510.546    245.52371    245.52371    23331.793    23331.793    1578.3662    1578.3662 
   43000   -8442.8149   -8442.8149   -8509.2059   -8509.2059    256.93992    256.93992    23375.664    23375.664   -1304.1924   -1304.1924 
Loop time of 119.491 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.192 hours/ns, 8.369 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    | 118.98     | 118.98     | 118.98     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096226   | 0.096226   | 0.096226   |   0.0 |  0.08
Output  | 0.00015343 | 0.00015343 | 0.00015343 |   0.0 |  0.00
Modify  | 0.3516     | 0.3516     | 0.3516     |   0.0 |  0.29
Other   |            | 0.05879    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128130.0 ave      128130 max      128130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128130
Ave neighs/atom = 64.065000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.998833885425, Press = -0.454083443701228
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8442.8149   -8442.8149   -8509.2059   -8509.2059    256.93992    256.93992    23375.664    23375.664   -1304.1924   -1304.1924 
   44000   -8446.4894   -8446.4894   -8512.3103   -8512.3103    254.73404    254.73404      23334.4      23334.4    1181.2825    1181.2825 
Loop time of 119.491 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.192 hours/ns, 8.369 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    | 118.98     | 118.98     | 118.98     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095836   | 0.095836   | 0.095836   |   0.0 |  0.08
Output  | 0.00015576 | 0.00015576 | 0.00015576 |   0.0 |  0.00
Modify  | 0.35183    | 0.35183    | 0.35183    |   0.0 |  0.29
Other   |            | 0.0592     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128070.0 ave      128070 max      128070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128070
Ave neighs/atom = 64.035000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.00529240618, Press = -0.258535640758299
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -8446.4894   -8446.4894   -8512.3103   -8512.3103    254.73404    254.73404      23334.4      23334.4    1181.2825    1181.2825 
   45000   -8445.0507   -8445.0507   -8510.7683   -8510.7683    254.33425    254.33425    23382.843    23382.843   -2070.3007   -2070.3007 
Loop time of 120.238 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.719 ns/day, 33.399 hours/ns, 8.317 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    | 119.73     | 119.73     | 119.73     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097193   | 0.097193   | 0.097193   |   0.0 |  0.08
Output  | 0.0001542  | 0.0001542  | 0.0001542  |   0.0 |  0.00
Modify  | 0.35554    | 0.35554    | 0.35554    |   0.0 |  0.30
Other   |            | 0.05869    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128104.0 ave      128104 max      128104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128104
Ave neighs/atom = 64.052000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.949452806093, Press = -2.10621499586857
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -8445.0507   -8445.0507   -8510.7683   -8510.7683    254.33425    254.33425    23382.843    23382.843   -2070.3007   -2070.3007 
   46000   -8445.4019   -8445.4019   -8511.9259   -8511.9259    257.45466    257.45466    23325.997    23325.997    2002.3532    2002.3532 
Loop time of 138.619 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.623 ns/day, 38.505 hours/ns, 7.214 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    | 138.01     | 138.01     | 138.01     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10761    | 0.10761    | 0.10761    |   0.0 |  0.08
Output  | 0.00018703 | 0.00018703 | 0.00018703 |   0.0 |  0.00
Modify  | 0.43452    | 0.43452    | 0.43452    |   0.0 |  0.31
Other   |            | 0.06501    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128094.0 ave      128094 max      128094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128094
Ave neighs/atom = 64.047000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.947151749006, Press = 1.25913648782265
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -8445.4019   -8445.4019   -8511.9259   -8511.9259    257.45466    257.45466    23325.997    23325.997    2002.3532    2002.3532 
   47000   -8446.7031   -8446.7031   -8511.9282   -8511.9282     252.4278     252.4278     23364.73     23364.73   -1066.5957   -1066.5957 
Loop time of 139.006 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.622 ns/day, 38.613 hours/ns, 7.194 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    | 138.39     | 138.39     | 138.39     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10881    | 0.10881    | 0.10881    |   0.0 |  0.08
Output  | 0.00015253 | 0.00015253 | 0.00015253 |   0.0 |  0.00
Modify  | 0.43949    | 0.43949    | 0.43949    |   0.0 |  0.32
Other   |            | 0.06497    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128122.0 ave      128122 max      128122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128122
Ave neighs/atom = 64.061000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.965743223908, Press = -1.99138112529366
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -8446.7031   -8446.7031   -8511.9282   -8511.9282     252.4278     252.4278     23364.73     23364.73   -1066.5957   -1066.5957 
   48000    -8448.192    -8448.192   -8512.2214   -8512.2214    247.80021    247.80021    23345.625    23345.625     314.0497     314.0497 
Loop time of 122.996 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.702 ns/day, 34.166 hours/ns, 8.130 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    | 122.47     | 122.47     | 122.47     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097974   | 0.097974   | 0.097974   |   0.0 |  0.08
Output  | 0.00015078 | 0.00015078 | 0.00015078 |   0.0 |  0.00
Modify  | 0.36619    | 0.36619    | 0.36619    |   0.0 |  0.30
Other   |            | 0.05996    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128112.0 ave      128112 max      128112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128112
Ave neighs/atom = 64.056000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.904891587267, Press = 0.148803069074333
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000    -8448.192    -8448.192   -8512.2214   -8512.2214    247.80021    247.80021    23345.625    23345.625     314.0497     314.0497 
   49000   -8445.7579   -8445.7579   -8511.4276   -8511.4276    254.14884    254.14884    23345.422    23345.422    498.52373    498.52373 
Loop time of 120.894 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.715 ns/day, 33.582 hours/ns, 8.272 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    | 120.38     | 120.38     | 120.38     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096786   | 0.096786   | 0.096786   |   0.0 |  0.08
Output  | 0.00021552 | 0.00021552 | 0.00021552 |   0.0 |  0.00
Modify  | 0.35761    | 0.35761    | 0.35761    |   0.0 |  0.30
Other   |            | 0.05885    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128116.0 ave      128116 max      128116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128116
Ave neighs/atom = 64.058000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.905731022722, Press = -1.56170024235244
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -8445.7579   -8445.7579   -8511.4276   -8511.4276    254.14884    254.14884    23345.422    23345.422    498.52373    498.52373 
   50000    -8443.704    -8443.704   -8510.2524   -8510.2524    257.54914    257.54914    23370.378    23370.378   -1117.0582   -1117.0582 
Loop time of 121.911 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.709 ns/day, 33.864 hours/ns, 8.203 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    | 121.39     | 121.39     | 121.39     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099268   | 0.099268   | 0.099268   |   0.0 |  0.08
Output  | 0.00020086 | 0.00020086 | 0.00020086 |   0.0 |  0.00
Modify  | 0.36362    | 0.36362    | 0.36362    |   0.0 |  0.30
Other   |            | 0.0588     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128124.0 ave      128124 max      128124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128124
Ave neighs/atom = 64.062000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.909541276657, Press = -0.199569797558416
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000    -8443.704    -8443.704   -8510.2524   -8510.2524    257.54914    257.54914    23370.378    23370.378   -1117.0582   -1117.0582 
   51000   -8447.1751   -8447.1751   -8513.5794   -8513.5794    256.99174    256.99174    23321.411    23321.411    1889.9583    1889.9583 
Loop time of 121.562 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.767 hours/ns, 8.226 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    | 121.04     | 121.04     | 121.04     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099057   | 0.099057   | 0.099057   |   0.0 |  0.08
Output  | 0.00015605 | 0.00015605 | 0.00015605 |   0.0 |  0.00
Modify  | 0.36157    | 0.36157    | 0.36157    |   0.0 |  0.30
Other   |            | 0.05806    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128134.0 ave      128134 max      128134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128134
Ave neighs/atom = 64.067000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.960526965872, Press = -1.14430212239338
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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -8447.1751   -8447.1751   -8513.5794   -8513.5794    256.99174    256.99174    23321.411    23321.411    1889.9583    1889.9583 
   52000   -8447.8683   -8447.8683   -8512.2766   -8512.2766    249.26678    249.26678    23396.384    23396.384   -3408.3379   -3408.3379 
Loop time of 131.221 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.658 ns/day, 36.450 hours/ns, 7.621 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    | 130.66     | 130.66     | 130.66     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10285    | 0.10285    | 0.10285    |   0.0 |  0.08
Output  | 0.00015691 | 0.00015691 | 0.00015691 |   0.0 |  0.00
Modify  | 0.39655    | 0.39655    | 0.39655    |   0.0 |  0.30
Other   |            | 0.0623     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 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:      128078.0 ave      128078 max      128078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0