# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.302343912422657*${_u_distance}
variable latticeconst_converted equal 3.302343912422657*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.30234391242266
Lattice spacing in x,y,z = 3.3023439 3.3023439 3.3023439
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 (33.023439 33.023439 33.023439)
  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 (33.023439 33.023439 33.023439)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Ta

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

kim interactions Ta
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_HuangLiuDuan_2021_HfNbTaTiZr__MO_893505888031_001
pair_coeff * * Ta
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 180.9479

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 36013.6300215875 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_893505888031_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16118.153   -16118.153   -16183.565   -16183.565       253.15       253.15     36013.63     36013.63     1940.033     1940.033 
    1000   -16049.876   -16049.876   -16109.472   -16109.472    230.64482    230.64482    36215.711    36215.711   -2072.0927   -2072.0927 
Loop time of 521.528 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.166 ns/day, 144.869 hours/ns, 1.917 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    | 521.04     | 521.04     | 521.04     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09494    | 0.09494    | 0.09494    |   0.0 |  0.02
Output  | 0.0001996  | 0.0001996  | 0.0001996  |   0.0 |  0.00
Modify  | 0.33839    | 0.33839    | 0.33839    |   0.0 |  0.06
Other   |            | 0.05886    |            |       |  0.01

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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16049.876   -16049.876   -16109.472   -16109.472    230.64482    230.64482    36215.711    36215.711   -2072.0927   -2072.0927 
    2000   -16049.718   -16049.718   -16115.961   -16115.961    256.36806    256.36806    36140.158    36140.158    1297.2892    1297.2892 
Loop time of 529.136 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.163 ns/day, 146.982 hours/ns, 1.890 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    | 528.65     | 528.65     | 528.65     |   0.0 | 99.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093491   | 0.093491   | 0.093491   |   0.0 |  0.02
Output  | 0.00019132 | 0.00019132 | 0.00019132 |   0.0 |  0.00
Modify  | 0.3321     | 0.3321     | 0.3321     |   0.0 |  0.06
Other   |            | 0.05855    |            |       |  0.01

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:      128380.0 ave      128380 max      128380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128380
Ave neighs/atom = 64.190000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16049.718   -16049.718   -16115.961   -16115.961    256.36806    256.36806    36140.158    36140.158    1297.2892    1297.2892 
    3000   -16051.559   -16051.559   -16119.167   -16119.167    261.64803    261.64803     36127.38     36127.38    1785.6832    1785.6832 
Loop time of 575.369 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.150 ns/day, 159.825 hours/ns, 1.738 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    | 574.81     | 574.81     | 574.81     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10315    | 0.10315    | 0.10315    |   0.0 |  0.02
Output  | 0.00022439 | 0.00022439 | 0.00022439 |   0.0 |  0.00
Modify  | 0.38914    | 0.38914    | 0.38914    |   0.0 |  0.07
Other   |            | 0.06328    |            |       |  0.01

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:      128334.0 ave      128334 max      128334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128334
Ave neighs/atom = 64.167000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16051.559   -16051.559   -16119.167   -16119.167    261.64803    261.64803     36127.38     36127.38    1785.6832    1785.6832 
    4000   -16051.769   -16051.769   -16114.196   -16114.196    241.59897    241.59897    36228.135    36228.135   -3288.1157   -3288.1157 
Loop time of 576.993 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.150 ns/day, 160.276 hours/ns, 1.733 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    | 576.43     | 576.43     | 576.43     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10351    | 0.10351    | 0.10351    |   0.0 |  0.02
Output  | 0.00019359 | 0.00019359 | 0.00019359 |   0.0 |  0.00
Modify  | 0.39417    | 0.39417    | 0.39417    |   0.0 |  0.07
Other   |            | 0.06324    |            |       |  0.01

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:      128298.0 ave      128298 max      128298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128298
Ave neighs/atom = 64.149000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16051.769   -16051.769   -16114.196   -16114.196    241.59897    241.59897    36228.135    36228.135   -3288.1157   -3288.1157 
    5000    -16051.52    -16051.52   -16116.006   -16116.006    249.56786    249.56786    36130.793    36130.793    1553.9474    1553.9474 
Loop time of 587.119 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.147 ns/day, 163.089 hours/ns, 1.703 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    | 586.54     | 586.54     | 586.54     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10452    | 0.10452    | 0.10452    |   0.0 |  0.02
Output  | 0.00016307 | 0.00016307 | 0.00016307 |   0.0 |  0.00
Modify  | 0.40588    | 0.40588    | 0.40588    |   0.0 |  0.07
Other   |            | 0.06442    |            |       |  0.01

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:      128438.0 ave      128438 max      128438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128438
Ave neighs/atom = 64.219000
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 = 245.361371716352, Press = -392.848333428723
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -16051.52    -16051.52   -16116.006   -16116.006    249.56786    249.56786    36130.793    36130.793    1553.9474    1553.9474 
    6000   -16052.187   -16052.187   -16115.114   -16115.114    243.53155    243.53155    36166.929    36166.929   -256.81313   -256.81313 
Loop time of 575.252 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.150 ns/day, 159.792 hours/ns, 1.738 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    | 574.68     | 574.68     | 574.68     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10248    | 0.10248    | 0.10248    |   0.0 |  0.02
Output  | 0.0001558  | 0.0001558  | 0.0001558  |   0.0 |  0.00
Modify  | 0.40834    | 0.40834    | 0.40834    |   0.0 |  0.07
Other   |            | 0.06326    |            |       |  0.01

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:      128388.0 ave      128388 max      128388 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128388
Ave neighs/atom = 64.194000
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.828634328998, Press = -7.56250475495331
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16052.187   -16052.187   -16115.114   -16115.114    243.53155    243.53155    36166.929    36166.929   -256.81313   -256.81313 
    7000   -16052.519   -16052.519   -16114.179   -16114.179    238.63111    238.63111    36209.444    36209.444   -2234.6398   -2234.6398 
Loop time of 568.105 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.152 ns/day, 157.807 hours/ns, 1.760 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    | 567.54     | 567.54     | 567.54     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10196    | 0.10196    | 0.10196    |   0.0 |  0.02
Output  | 0.00019742 | 0.00019742 | 0.00019742 |   0.0 |  0.00
Modify  | 0.39784    | 0.39784    | 0.39784    |   0.0 |  0.07
Other   |            | 0.06329    |            |       |  0.01

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:      128452.0 ave      128452 max      128452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128452
Ave neighs/atom = 64.226000
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.447481162832, Press = -15.0086078684285
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16052.519   -16052.519   -16114.179   -16114.179    238.63111    238.63111    36209.444    36209.444   -2234.6398   -2234.6398 
    8000   -16051.292   -16051.292   -16119.387   -16119.387    263.53193    263.53193    36105.951    36105.951    2756.7542    2756.7542 
Loop time of 580.906 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.149 ns/day, 161.363 hours/ns, 1.721 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    | 580.32     | 580.32     | 580.32     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10386    | 0.10386    | 0.10386    |   0.0 |  0.02
Output  | 0.00019391 | 0.00019391 | 0.00019391 |   0.0 |  0.00
Modify  | 0.41577    | 0.41577    | 0.41577    |   0.0 |  0.07
Other   |            | 0.06425    |            |       |  0.01

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:      128320.0 ave      128320 max      128320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128320
Ave neighs/atom = 64.160000
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.272225857991, Press = -6.61973443201279
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16051.292   -16051.292   -16119.387   -16119.387    263.53193    263.53193    36105.951    36105.951    2756.7542    2756.7542 
    9000   -16051.461   -16051.461   -16121.158   -16121.158    269.73574    269.73574    36140.274    36140.274    1002.8846    1002.8846 
Loop time of 587.797 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.147 ns/day, 163.277 hours/ns, 1.701 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    | 587.21     | 587.21     | 587.21     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1059     | 0.1059     | 0.1059     |   0.0 |  0.02
Output  | 0.00025638 | 0.00025638 | 0.00025638 |   0.0 |  0.00
Modify  | 0.42081    | 0.42081    | 0.42081    |   0.0 |  0.07
Other   |            | 0.06481    |            |       |  0.01

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:      128368.0 ave      128368 max      128368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128368
Ave neighs/atom = 64.184000
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.824802777851, Press = -6.77679348687087
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16051.461   -16051.461   -16121.158   -16121.158    269.73574    269.73574    36140.274    36140.274    1002.8846    1002.8846 
   10000   -16051.301   -16051.301   -16119.111   -16119.111    262.43251    262.43251    36136.223    36136.223    1292.0937    1292.0937 
Loop time of 574.918 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.150 ns/day, 159.699 hours/ns, 1.739 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    | 574.34     | 574.34     | 574.34     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10378    | 0.10378    | 0.10378    |   0.0 |  0.02
Output  | 0.00019581 | 0.00019581 | 0.00019581 |   0.0 |  0.00
Modify  | 0.41       | 0.41       | 0.41       |   0.0 |  0.07
Other   |            | 0.0634     |            |       |  0.01

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:      128296.0 ave      128296 max      128296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128296
Ave neighs/atom = 64.148000
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.108355058417, Press = -9.52998920457286
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16051.301   -16051.301   -16119.111   -16119.111    262.43251    262.43251    36136.223    36136.223    1292.0937    1292.0937 
   11000   -16053.128   -16053.128   -16114.066   -16114.066    235.83889    235.83889    36190.316    36190.316   -1337.9454   -1337.9454 
Loop time of 596.815 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.782 hours/ns, 1.676 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    | 596.21     | 596.21     | 596.21     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10636    | 0.10636    | 0.10636    |   0.0 |  0.02
Output  | 0.00021997 | 0.00021997 | 0.00021997 |   0.0 |  0.00
Modify  | 0.43765    | 0.43765    | 0.43765    |   0.0 |  0.07
Other   |            | 0.06502    |            |       |  0.01

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:      128392.0 ave      128392 max      128392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128392
Ave neighs/atom = 64.196000
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.973153337679, Press = 2.03562589145345
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16053.128   -16053.128   -16114.066   -16114.066    235.83889    235.83889    36190.316    36190.316   -1337.9454   -1337.9454 
   12000   -16050.589   -16050.589   -16117.081   -16117.081     257.3286     257.3286    36167.672    36167.672   -133.31497   -133.31497 
Loop time of 583.428 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.148 ns/day, 162.063 hours/ns, 1.714 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    | 582.84     | 582.84     | 582.84     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10447    | 0.10447    | 0.10447    |   0.0 |  0.02
Output  | 0.00015768 | 0.00015768 | 0.00015768 |   0.0 |  0.00
Modify  | 0.41556    | 0.41556    | 0.41556    |   0.0 |  0.07
Other   |            | 0.06335    |            |       |  0.01

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:      128392.0 ave      128392 max      128392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128392
Ave neighs/atom = 64.196000
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.956893238909, Press = -5.65086047062058
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16050.589   -16050.589   -16117.081   -16117.081     257.3286     257.3286    36167.672    36167.672   -133.31497   -133.31497 
   13000    -16052.93    -16052.93   -16116.917   -16116.917    247.63689    247.63689    36144.104    36144.104    947.60422    947.60422 
Loop time of 597.227 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.145 ns/day, 165.896 hours/ns, 1.674 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 596.61     | 596.61     | 596.61     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10743    | 0.10743    | 0.10743    |   0.0 |  0.02
Output  | 0.00019522 | 0.00019522 | 0.00019522 |   0.0 |  0.00
Modify  | 0.43976    | 0.43976    | 0.43976    |   0.0 |  0.07
Other   |            | 0.06606    |            |       |  0.01

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:      128300.0 ave      128300 max      128300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128300
Ave neighs/atom = 64.150000
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.024072075511, Press = -3.13755436511379
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -16052.93    -16052.93   -16116.917   -16116.917    247.63689    247.63689    36144.104    36144.104    947.60422    947.60422 
   14000   -16050.968   -16050.968   -16116.366   -16116.366    253.09781    253.09781    36168.632    36168.632     -236.348     -236.348 
Loop time of 599.685 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.579 hours/ns, 1.668 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    | 599.08     | 599.08     | 599.08     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10655    | 0.10655    | 0.10655    |   0.0 |  0.02
Output  | 0.00020937 | 0.00020937 | 0.00020937 |   0.0 |  0.00
Modify  | 0.43553    | 0.43553    | 0.43553    |   0.0 |  0.07
Other   |            | 0.06567    |            |       |  0.01

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:      128400.0 ave      128400 max      128400 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128400
Ave neighs/atom = 64.200000
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.99569646581, Press = -2.95687793218221
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16050.968   -16050.968   -16116.366   -16116.366    253.09781    253.09781    36168.632    36168.632     -236.348     -236.348 
   15000   -16054.178   -16054.178   -16115.501   -16115.501     237.3263     237.3263    36173.306    36173.306   -476.92718   -476.92718 
Loop time of 591.124 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.146 ns/day, 164.201 hours/ns, 1.692 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    | 590.53     | 590.53     | 590.53     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10427    | 0.10427    | 0.10427    |   0.0 |  0.02
Output  | 0.00015339 | 0.00015339 | 0.00015339 |   0.0 |  0.00
Modify  | 0.42141    | 0.42141    | 0.42141    |   0.0 |  0.07
Other   |            | 0.06471    |            |       |  0.01

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:      128326.0 ave      128326 max      128326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128326
Ave neighs/atom = 64.163000
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.782030815195, Press = -4.7634193375905
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16054.178   -16054.178   -16115.501   -16115.501     237.3263     237.3263    36173.306    36173.306   -476.92718   -476.92718 
   16000   -16048.308   -16048.308   -16119.317   -16119.317    274.80936    274.80936    36144.775    36144.775    966.02223    966.02223 
Loop time of 581.698 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.149 ns/day, 161.583 hours/ns, 1.719 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    | 581.12     | 581.12     | 581.12     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10217    | 0.10217    | 0.10217    |   0.0 |  0.02
Output  | 0.00015604 | 0.00015604 | 0.00015604 |   0.0 |  0.00
Modify  | 0.41202    | 0.41202    | 0.41202    |   0.0 |  0.07
Other   |            | 0.06327    |            |       |  0.01

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:      128368.0 ave      128368 max      128368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128368
Ave neighs/atom = 64.184000
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.87560759953, Press = 0.353577453281422
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16048.308   -16048.308   -16119.317   -16119.317    274.80936    274.80936    36144.775    36144.775    966.02223    966.02223 
   17000   -16054.228   -16054.228   -16116.753   -16116.753    241.97884    241.97884    36196.489    36196.489   -1817.6995   -1817.6995 
Loop time of 602.672 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.409 hours/ns, 1.659 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    | 602.06     | 602.06     | 602.06     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1067     | 0.1067     | 0.1067     |   0.0 |  0.02
Output  | 0.00015633 | 0.00015633 | 0.00015633 |   0.0 |  0.00
Modify  | 0.44092    | 0.44092    | 0.44092    |   0.0 |  0.07
Other   |            | 0.06606    |            |       |  0.01

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:      128280.0 ave      128280 max      128280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128280
Ave neighs/atom = 64.140000
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.881955943629, Press = -3.49163233061876
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16054.228   -16054.228   -16116.753   -16116.753    241.97884    241.97884    36196.489    36196.489   -1817.6995   -1817.6995 
   18000   -16052.689   -16052.689   -16119.255   -16119.255     257.6154     257.6154    36127.816    36127.816    1649.3916    1649.3916 
Loop time of 601.924 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 167.201 hours/ns, 1.661 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    | 601.31     | 601.31     | 601.31     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10672    | 0.10672    | 0.10672    |   0.0 |  0.02
Output  | 0.00015698 | 0.00015698 | 0.00015698 |   0.0 |  0.00
Modify  | 0.44069    | 0.44069    | 0.44069    |   0.0 |  0.07
Other   |            | 0.06589    |            |       |  0.01

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:      128288.0 ave      128288 max      128288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128288
Ave neighs/atom = 64.144000
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.806289084107, Press = -0.774256529690516
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16052.689   -16052.689   -16119.255   -16119.255     257.6154     257.6154    36127.816    36127.816    1649.3916    1649.3916 
   19000   -16049.659   -16049.659   -16114.144   -16114.144    249.56251    249.56251    36165.381    36165.381    201.46728    201.46728 
Loop time of 585.089 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.148 ns/day, 162.525 hours/ns, 1.709 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    | 584.5      | 584.5      | 584.5      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10467    | 0.10467    | 0.10467    |   0.0 |  0.02
Output  | 0.00023509 | 0.00023509 | 0.00023509 |   0.0 |  0.00
Modify  | 0.42241    | 0.42241    | 0.42241    |   0.0 |  0.07
Other   |            | 0.06395    |            |       |  0.01

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:      128258.0 ave      128258 max      128258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128258
Ave neighs/atom = 64.129000
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.786369853986, Press = -0.980387397748345
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16049.659   -16049.659   -16114.144   -16114.144    249.56251    249.56251    36165.381    36165.381    201.46728    201.46728 
   20000    -16051.62    -16051.62   -16118.898   -16118.898    260.37249    260.37249    36178.601    36178.601   -864.43092   -864.43092 
Loop time of 602.898 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.472 hours/ns, 1.659 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    | 602.28     | 602.28     | 602.28     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10729    | 0.10729    | 0.10729    |   0.0 |  0.02
Output  | 0.00019428 | 0.00019428 | 0.00019428 |   0.0 |  0.00
Modify  | 0.43963    | 0.43963    | 0.43963    |   0.0 |  0.07
Other   |            | 0.0657     |            |       |  0.01

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:      128382.0 ave      128382 max      128382 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128382
Ave neighs/atom = 64.191000
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.948987438002, Press = -6.18080271563034
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -16051.62    -16051.62   -16118.898   -16118.898    260.37249    260.37249    36178.601    36178.601   -864.43092   -864.43092 
   21000   -16050.595   -16050.595   -16119.287   -16119.287    265.84351    265.84351    36184.329    36184.329   -1253.9518   -1253.9518 
Loop time of 578.388 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.149 ns/day, 160.663 hours/ns, 1.729 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    | 577.81     | 577.81     | 577.81     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10242    | 0.10242    | 0.10242    |   0.0 |  0.02
Output  | 0.00015648 | 0.00015648 | 0.00015648 |   0.0 |  0.00
Modify  | 0.41186    | 0.41186    | 0.41186    |   0.0 |  0.07
Other   |            | 0.0645     |            |       |  0.01

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:      128286.0 ave      128286 max      128286 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128286
Ave neighs/atom = 64.143000
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.985312615769, Press = -1.4901958295888
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16050.595   -16050.595   -16119.287   -16119.287    265.84351    265.84351    36184.329    36184.329   -1253.9518   -1253.9518 
   22000    -16049.99    -16049.99   -16115.365   -16115.365    253.00767    253.00767     36178.61     36178.61   -728.60415   -728.60415 
Loop time of 604.977 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 168.049 hours/ns, 1.653 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    | 604.36     | 604.36     | 604.36     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10542    | 0.10542    | 0.10542    |   0.0 |  0.02
Output  | 0.00019259 | 0.00019259 | 0.00019259 |   0.0 |  0.00
Modify  | 0.44086    | 0.44086    | 0.44086    |   0.0 |  0.07
Other   |            | 0.06554    |            |       |  0.01

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:      128244.0 ave      128244 max      128244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128244
Ave neighs/atom = 64.122000
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.027012798253, Press = -1.22042655609896
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -16049.99    -16049.99   -16115.365   -16115.365    253.00767    253.00767     36178.61     36178.61   -728.60415   -728.60415 
   23000   -16051.303   -16051.303    -16121.31    -16121.31    270.93335    270.93335    36138.309    36138.309    1148.4489    1148.4489 
Loop time of 603.286 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.579 hours/ns, 1.658 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    | 602.68     | 602.68     | 602.68     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10491    | 0.10491    | 0.10491    |   0.0 |  0.02
Output  | 0.00019059 | 0.00019059 | 0.00019059 |   0.0 |  0.00
Modify  | 0.43754    | 0.43754    | 0.43754    |   0.0 |  0.07
Other   |            | 0.06457    |            |       |  0.01

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:      128376.0 ave      128376 max      128376 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128376
Ave neighs/atom = 64.188000
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.998870033416, Press = -0.32948432483776
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16051.303   -16051.303    -16121.31    -16121.31    270.93335    270.93335    36138.309    36138.309    1148.4489    1148.4489 
   24000   -16051.494   -16051.494   -16114.004   -16114.004    241.92039    241.92039    36093.603    36093.603     3904.714     3904.714 
Loop time of 606.805 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.142 ns/day, 168.557 hours/ns, 1.648 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 606.19     | 606.19     | 606.19     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10427    | 0.10427    | 0.10427    |   0.0 |  0.02
Output  | 0.00019539 | 0.00019539 | 0.00019539 |   0.0 |  0.00
Modify  | 0.44178    | 0.44178    | 0.44178    |   0.0 |  0.07
Other   |            | 0.06557    |            |       |  0.01

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:      128306.0 ave      128306 max      128306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128306
Ave neighs/atom = 64.153000
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.036451633235, Press = 0.796265892668563
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16051.494   -16051.494   -16114.004   -16114.004    241.92039    241.92039    36093.603    36093.603     3904.714     3904.714 
   25000   -16051.437   -16051.437   -16114.993   -16114.993    245.97005    245.97005    36165.277    36165.277   -63.947767   -63.947767 
Loop time of 561.454 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.154 ns/day, 155.959 hours/ns, 1.781 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    | 560.9      | 560.9      | 560.9      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098728   | 0.098728   | 0.098728   |   0.0 |  0.02
Output  | 0.00015395 | 0.00015395 | 0.00015395 |   0.0 |  0.00
Modify  | 0.39341    | 0.39341    | 0.39341    |   0.0 |  0.07
Other   |            | 0.06316    |            |       |  0.01

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:      128436.0 ave      128436 max      128436 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128436
Ave neighs/atom = 64.218000
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.979447092214, Press = -2.74903036292557
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16051.437   -16051.437   -16114.993   -16114.993    245.97005    245.97005    36165.277    36165.277   -63.947767   -63.947767 
   26000   -16050.642   -16050.642   -16114.946   -16114.946    248.86032    248.86032     36191.74     36191.74   -1321.4791   -1321.4791 
Loop time of 537.455 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.161 ns/day, 149.293 hours/ns, 1.861 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    | 536.94     | 536.94     | 536.94     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09471    | 0.09471    | 0.09471    |   0.0 |  0.02
Output  | 0.00015582 | 0.00015582 | 0.00015582 |   0.0 |  0.00
Modify  | 0.35761    | 0.35761    | 0.35761    |   0.0 |  0.07
Other   |            | 0.06019    |            |       |  0.01

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:      128430.0 ave      128430 max      128430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128430
Ave neighs/atom = 64.215000
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.032864511991, Press = -1.2252526063231
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16050.642   -16050.642   -16114.946   -16114.946    248.86032    248.86032     36191.74     36191.74   -1321.4791   -1321.4791 
   27000   -16052.932   -16052.932   -16117.369   -16117.369    249.37973    249.37973    36169.497    36169.497   -380.74877   -380.74877 
Loop time of 538.719 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.160 ns/day, 149.644 hours/ns, 1.856 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    | 538.2      | 538.2      | 538.2      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094623   | 0.094623   | 0.094623   |   0.0 |  0.02
Output  | 0.00019778 | 0.00019778 | 0.00019778 |   0.0 |  0.00
Modify  | 0.35913    | 0.35913    | 0.35913    |   0.0 |  0.07
Other   |            | 0.06006    |            |       |  0.01

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:      128332.0 ave      128332 max      128332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128332
Ave neighs/atom = 64.166000
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.018190256522, Press = -1.41953932937659
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16052.932   -16052.932   -16117.369   -16117.369    249.37973    249.37973    36169.497    36169.497   -380.74877   -380.74877 
   28000   -16053.614   -16053.614   -16119.541   -16119.541    255.14289    255.14289    36137.341    36137.341    1128.3281    1128.3281 
Loop time of 603.417 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 167.616 hours/ns, 1.657 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    | 602.79     | 602.79     | 602.79     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10897    | 0.10897    | 0.10897    |   0.0 |  0.02
Output  | 0.00023775 | 0.00023775 | 0.00023775 |   0.0 |  0.00
Modify  | 0.44932    | 0.44932    | 0.44932    |   0.0 |  0.07
Other   |            | 0.06823    |            |       |  0.01

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:      128320.0 ave      128320 max      128320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128320
Ave neighs/atom = 64.160000
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.047490510778, Press = -0.412021376866206
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16053.614   -16053.614   -16119.541   -16119.541    255.14289    255.14289    36137.341    36137.341    1128.3281    1128.3281 
   29000   -16052.287   -16052.287   -16116.808   -16116.808    249.70271    249.70271    36197.267    36197.267   -1682.6647   -1682.6647 
Loop time of 600.822 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.895 hours/ns, 1.664 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    | 600.21     | 600.21     | 600.21     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10708    | 0.10708    | 0.10708    |   0.0 |  0.02
Output  | 0.00015517 | 0.00015517 | 0.00015517 |   0.0 |  0.00
Modify  | 0.44337    | 0.44337    | 0.44337    |   0.0 |  0.07
Other   |            | 0.06649    |            |       |  0.01

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:      128308.0 ave      128308 max      128308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128308
Ave neighs/atom = 64.154000
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.058761207424, Press = -0.563431071545052
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16052.287   -16052.287   -16116.808   -16116.808    249.70271    249.70271    36197.267    36197.267   -1682.6647   -1682.6647 
   30000   -16051.504   -16051.504   -16115.261   -16115.261    246.74765    246.74765    36120.107    36120.107     2330.031     2330.031 
Loop time of 568.005 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.152 ns/day, 157.779 hours/ns, 1.761 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    | 567.45     | 567.45     | 567.45     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099842   | 0.099842   | 0.099842   |   0.0 |  0.02
Output  | 0.00015653 | 0.00015653 | 0.00015653 |   0.0 |  0.00
Modify  | 0.39434    | 0.39434    | 0.39434    |   0.0 |  0.07
Other   |            | 0.06232    |            |       |  0.01

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:      128318.0 ave      128318 max      128318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128318
Ave neighs/atom = 64.159000
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.085023571761, Press = -1.07716250805773
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16051.504   -16051.504   -16115.261   -16115.261    246.74765    246.74765    36120.107    36120.107     2330.031     2330.031 
   31000   -16053.322   -16053.322   -16117.581   -16117.581    248.68915    248.68915    36189.993    36189.993    -1508.846    -1508.846 
Loop time of 600.543 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.818 hours/ns, 1.665 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    | 599.93     | 599.93     | 599.93     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10675    | 0.10675    | 0.10675    |   0.0 |  0.02
Output  | 0.00015659 | 0.00015659 | 0.00015659 |   0.0 |  0.00
Modify  | 0.4357     | 0.4357     | 0.4357     |   0.0 |  0.07
Other   |            | 0.06589    |            |       |  0.01

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:      128430.0 ave      128430 max      128430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128430
Ave neighs/atom = 64.215000
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.082935707639, Press = -1.79217226796703
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16053.322   -16053.322   -16117.581   -16117.581    248.68915    248.68915    36189.993    36189.993    -1508.846    -1508.846 
   32000   -16051.872   -16051.872   -16116.115   -16116.115    248.62879    248.62879    36173.342    36173.342    -494.6821    -494.6821 
Loop time of 536.51 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.161 ns/day, 149.030 hours/ns, 1.864 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    | 536        | 536        | 536        |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095426   | 0.095426   | 0.095426   |   0.0 |  0.02
Output  | 0.00015603 | 0.00015603 | 0.00015603 |   0.0 |  0.00
Modify  | 0.35774    | 0.35774    | 0.35774    |   0.0 |  0.07
Other   |            | 0.05975    |            |       |  0.01

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:      128356.0 ave      128356 max      128356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128356
Ave neighs/atom = 64.178000
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.083108436269, Press = -0.558100370953617
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16051.872   -16051.872   -16116.115   -16116.115    248.62879    248.62879    36173.342    36173.342    -494.6821    -494.6821 
   33000    -16046.93    -16046.93   -16113.893   -16113.893     259.1518     259.1518    36141.973    36141.973    1445.5796    1445.5796 
Loop time of 558.057 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.155 ns/day, 155.016 hours/ns, 1.792 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    | 557.51     | 557.51     | 557.51     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09859    | 0.09859    | 0.09859    |   0.0 |  0.02
Output  | 0.00019546 | 0.00019546 | 0.00019546 |   0.0 |  0.00
Modify  | 0.38311    | 0.38311    | 0.38311    |   0.0 |  0.07
Other   |            | 0.06234    |            |       |  0.01

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:      128354.0 ave      128354 max      128354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128354
Ave neighs/atom = 64.177000
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.134327107355, Press = -0.372467215346153
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -16046.93    -16046.93   -16113.893   -16113.893     259.1518     259.1518    36141.973    36141.973    1445.5796    1445.5796 
   34000    -16051.53    -16051.53   -16116.544   -16116.544    251.60911    251.60911    36178.967    36178.967   -721.91767   -721.91767 
Loop time of 598.083 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.134 hours/ns, 1.672 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    | 597.48     | 597.48     | 597.48     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10616    | 0.10616    | 0.10616    |   0.0 |  0.02
Output  | 0.00019221 | 0.00019221 | 0.00019221 |   0.0 |  0.00
Modify  | 0.43383    | 0.43383    | 0.43383    |   0.0 |  0.07
Other   |            | 0.06552    |            |       |  0.01

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:      128428.0 ave      128428 max      128428 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128428
Ave neighs/atom = 64.214000
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.169399333876, Press = -1.83472212254799
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -16051.53    -16051.53   -16116.544   -16116.544    251.60911    251.60911    36178.967    36178.967   -721.91767   -721.91767 
   35000   -16049.402   -16049.402   -16118.056   -16118.056    265.69723    265.69723    36155.106    36155.106    498.96945    498.96945 
Loop time of 605.209 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.143 ns/day, 168.114 hours/ns, 1.652 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    | 604.6      | 604.6      | 604.6      |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10546    | 0.10546    | 0.10546    |   0.0 |  0.02
Output  | 0.00018982 | 0.00018982 | 0.00018982 |   0.0 |  0.00
Modify  | 0.44122    | 0.44122    | 0.44122    |   0.0 |  0.07
Other   |            | 0.06556    |            |       |  0.01

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:      128302.0 ave      128302 max      128302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128302
Ave neighs/atom = 64.151000
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.157386528398, Press = -0.781711831586258
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16049.402   -16049.402   -16118.056   -16118.056    265.69723    265.69723    36155.106    36155.106    498.96945    498.96945 
   36000   -16049.706   -16049.706   -16115.582   -16115.582    254.94941    254.94941    36188.321    36188.321   -1171.2623   -1171.2623 
Loop time of 600.613 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 166.837 hours/ns, 1.665 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    | 600        | 600        | 600        |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10587    | 0.10587    | 0.10587    |   0.0 |  0.02
Output  | 0.00023209 | 0.00023209 | 0.00023209 |   0.0 |  0.00
Modify  | 0.44093    | 0.44093    | 0.44093    |   0.0 |  0.07
Other   |            | 0.0653     |            |       |  0.01

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:      128318.0 ave      128318 max      128318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128318
Ave neighs/atom = 64.159000
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.16899067068, Press = -0.647090449669607
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -16049.706   -16049.706   -16115.582   -16115.582    254.94941    254.94941    36188.321    36188.321   -1171.2623   -1171.2623 
   37000   -16051.255   -16051.255   -16114.494   -16114.494    244.74177    244.74177    36158.524    36158.524    452.48686    452.48686 
Loop time of 601.826 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.144 ns/day, 167.174 hours/ns, 1.662 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    | 601.21     | 601.21     | 601.21     |   0.0 | 99.90
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10793    | 0.10793    | 0.10793    |   0.0 |  0.02
Output  | 0.00015751 | 0.00015751 | 0.00015751 |   0.0 |  0.00
Modify  | 0.4409     | 0.4409     | 0.4409     |   0.0 |  0.07
Other   |            | 0.06615    |            |       |  0.01

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:      128288.0 ave      128288 max      128288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128288
Ave neighs/atom = 64.144000
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
36163.7323507229

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0