# 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 4.079999998211861*${_u_distance}
variable latticeconst_converted equal 4.079999998211861*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.07999999821186
Lattice spacing in x,y,z = 4.0800000 4.0800000 4.0800000
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 (40.800000 40.800000 40.800000)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (40.800000 40.800000 40.800000)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Ag

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

kim interactions Ag
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_GaoOteroAouadi_2013_AgTaO__MO_112077942578_001
pair_coeff * * Ag
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 107.8682

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 67917.3119107017 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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_112077942578_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -11227.791   -11227.791       -11400       -11400       333.15       333.15    67917.312    67917.312     2708.289     2708.289 
    1000   -11092.448   -11092.448   -11261.531   -11261.531    327.10175    327.10175    68565.087    68565.087    26.359273    26.359273 
Loop time of 421.576 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 420.55     | 420.55     | 420.55     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2068     | 0.2068     | 0.2068     |   0.0 |  0.05
Output  | 0.0002243  | 0.0002243  | 0.0002243  |   0.0 |  0.00
Modify  | 0.71393    | 0.71393    | 0.71393    |   0.0 |  0.17
Other   |            | 0.1028     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      560000.0 ave      560000 max      560000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 560000
Ave neighs/atom = 140.00000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -11092.448   -11092.448   -11261.531   -11261.531    327.10175    327.10175    68565.087    68565.087    26.359273    26.359273 
    2000    -11081.04    -11081.04   -11254.938   -11254.938    336.41733    336.41733    68603.865    68603.865   -253.32077   -253.32077 
Loop time of 414.862 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.239 hours/ns, 2.410 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    | 413.88     | 413.88     | 413.88     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18009    | 0.18009    | 0.18009    |   0.0 |  0.04
Output  | 0.00021546 | 0.00021546 | 0.00021546 |   0.0 |  0.00
Modify  | 0.69959    | 0.69959    | 0.69959    |   0.0 |  0.17
Other   |            | 0.102      |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7084.00 ave        7084 max        7084 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:      548852.0 ave      548852 max      548852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548852
Ave neighs/atom = 137.21300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.472 | 5.472 | 5.472 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000    -11081.04    -11081.04   -11254.938   -11254.938    336.41733    336.41733    68603.865    68603.865   -253.32077   -253.32077 
    3000    -11083.43    -11083.43    -11257.64    -11257.64     337.0204     337.0204    68572.928    68572.928    187.36928    187.36928 
Loop time of 453.662 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.190 ns/day, 126.017 hours/ns, 2.204 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    | 452.56     | 452.56     | 452.56     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19396    | 0.19396    | 0.19396    |   0.0 |  0.04
Output  | 0.0002667  | 0.0002667  | 0.0002667  |   0.0 |  0.00
Modify  | 0.7941     | 0.7941     | 0.7941     |   0.0 |  0.18
Other   |            | 0.11       |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7018.00 ave        7018 max        7018 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:      548778.0 ave      548778 max      548778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548778
Ave neighs/atom = 137.19450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000    -11083.43    -11083.43    -11257.64    -11257.64     337.0204     337.0204    68572.928    68572.928    187.36928    187.36928 
    4000     -11090.1     -11090.1   -11258.738   -11258.738    326.24256    326.24256    68588.416    68588.416   -410.93494   -410.93494 
Loop time of 426.836 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 425.83     | 425.83     | 425.83     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18309    | 0.18309    | 0.18309    |   0.0 |  0.04
Output  | 0.00021816 | 0.00021816 | 0.00021816 |   0.0 |  0.00
Modify  | 0.71892    | 0.71892    | 0.71892    |   0.0 |  0.17
Other   |            | 0.1035     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7093.00 ave        7093 max        7093 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:      548870.0 ave      548870 max      548870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548870
Ave neighs/atom = 137.21750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000     -11090.1     -11090.1   -11258.738   -11258.738    326.24256    326.24256    68588.416    68588.416   -410.93494   -410.93494 
    5000   -11084.967   -11084.967   -11258.749   -11258.749    336.19362    336.19362    68536.524    68536.524    504.78354    504.78354 
Loop time of 392.863 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.129 hours/ns, 2.545 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 391.95     | 391.95     | 391.95     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17403    | 0.17403    | 0.17403    |   0.0 |  0.04
Output  | 0.0001799  | 0.0001799  | 0.0001799  |   0.0 |  0.00
Modify  | 0.64025    | 0.64025    | 0.64025    |   0.0 |  0.16
Other   |            | 0.09742    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7139.00 ave        7139 max        7139 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:      548782.0 ave      548782 max      548782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548782
Ave neighs/atom = 137.19550
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 = 333.928751094575, Press = 20.9421364975382
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -11084.967   -11084.967   -11258.749   -11258.749    336.19362    336.19362    68536.524    68536.524    504.78354    504.78354 
    6000   -11086.423   -11086.423   -11258.935   -11258.935    333.73745    333.73745    68566.954    68566.954    176.63417    176.63417 
Loop time of 392.249 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 108.958 hours/ns, 2.549 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    | 391.32     | 391.32     | 391.32     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17603    | 0.17603    | 0.17603    |   0.0 |  0.04
Output  | 0.00017918 | 0.00017918 | 0.00017918 |   0.0 |  0.00
Modify  | 0.66105    | 0.66105    | 0.66105    |   0.0 |  0.17
Other   |            | 0.09648    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7142.00 ave        7142 max        7142 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:      548936.0 ave      548936 max      548936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548936
Ave neighs/atom = 137.23400
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 = 332.756176806745, Press = -4.70079674766496
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -11086.423   -11086.423   -11258.935   -11258.935    333.73745    333.73745    68566.954    68566.954    176.63417    176.63417 
    7000   -11085.162   -11085.162   -11259.447   -11259.447    337.16525    337.16525    68571.642    68571.642    58.356039    58.356039 
Loop time of 411.825 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.396 hours/ns, 2.428 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    | 410.84     | 410.84     | 410.84     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18022    | 0.18022    | 0.18022    |   0.0 |  0.04
Output  | 0.00017996 | 0.00017996 | 0.00017996 |   0.0 |  0.00
Modify  | 0.70782    | 0.70782    | 0.70782    |   0.0 |  0.17
Other   |            | 0.1004     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7154.00 ave        7154 max        7154 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:      548926.0 ave      548926 max      548926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548926
Ave neighs/atom = 137.23150
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 = 333.097115413127, Press = -18.0255008055744
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -11085.162   -11085.162   -11259.447   -11259.447    337.16525    337.16525    68571.642    68571.642    58.356039    58.356039 
    8000   -11085.513   -11085.513   -11259.167   -11259.167    335.94491    335.94491    68445.446    68445.446    1873.4927    1873.4927 
Loop time of 459.616 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.671 hours/ns, 2.176 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    | 458.48     | 458.48     | 458.48     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1948     | 0.1948     | 0.1948     |   0.0 |  0.04
Output  | 0.0003041  | 0.0003041  | 0.0003041  |   0.0 |  0.00
Modify  | 0.82643    | 0.82643    | 0.82643    |   0.0 |  0.18
Other   |            | 0.1105     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7090.00 ave        7090 max        7090 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:      548852.0 ave      548852 max      548852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548852
Ave neighs/atom = 137.21300
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 = 333.114678454256, Press = 2.1394320494228
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -11085.513   -11085.513   -11259.167   -11259.167    335.94491    335.94491    68445.446    68445.446    1873.4927    1873.4927 
    9000   -11084.191   -11084.191   -11257.691   -11257.691    335.64669    335.64669    68624.584    68624.584   -827.10744   -827.10744 
Loop time of 441.568 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.196 ns/day, 122.658 hours/ns, 2.265 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    | 440.49     | 440.49     | 440.49     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18906    | 0.18906    | 0.18906    |   0.0 |  0.04
Output  | 0.00022146 | 0.00022146 | 0.00022146 |   0.0 |  0.00
Modify  | 0.78271    | 0.78271    | 0.78271    |   0.0 |  0.18
Other   |            | 0.1048     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7055.00 ave        7055 max        7055 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:      549214.0 ave      549214 max      549214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 549214
Ave neighs/atom = 137.30350
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 = 333.39886340238, Press = 4.64785148451808
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.472 | 5.472 | 5.472 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -11084.191   -11084.191   -11257.691   -11257.691    335.64669    335.64669    68624.584    68624.584   -827.10744   -827.10744 
   10000   -11085.083   -11085.083   -11257.928   -11257.928    334.37963    334.37963    68563.318    68563.318    82.575464    82.575464 
Loop time of 462.442 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.456 hours/ns, 2.162 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    | 461.29     | 461.29     | 461.29     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19461    | 0.19461    | 0.19461    |   0.0 |  0.04
Output  | 0.00025404 | 0.00025404 | 0.00025404 |   0.0 |  0.00
Modify  | 0.84382    | 0.84382    | 0.84382    |   0.0 |  0.18
Other   |            | 0.1109     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7028.00 ave        7028 max        7028 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:      548732.0 ave      548732 max      548732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548732
Ave neighs/atom = 137.18300
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 = 333.428991383655, Press = -1.89248492209257
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -11085.083   -11085.083   -11257.928   -11257.928    334.37963    334.37963    68563.318    68563.318    82.575464    82.575464 
   11000   -11086.902   -11086.902   -11256.772   -11256.772    328.62505    328.62505    68624.388    68624.388   -1038.7382   -1038.7382 
Loop time of 451.367 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.191 ns/day, 125.380 hours/ns, 2.215 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    | 450.26     | 450.26     | 450.26     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19298    | 0.19298    | 0.19298    |   0.0 |  0.04
Output  | 0.00017949 | 0.00017949 | 0.00017949 |   0.0 |  0.00
Modify  | 0.80827    | 0.80827    | 0.80827    |   0.0 |  0.18
Other   |            | 0.1074     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7159.00 ave        7159 max        7159 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:      548952.0 ave      548952 max      548952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548952
Ave neighs/atom = 137.23800
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 = 333.520862891559, Press = -2.4633588456318
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.474 | 5.474 | 5.474 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -11086.902   -11086.902   -11256.772   -11256.772    328.62505    328.62505    68624.388    68624.388   -1038.7382   -1038.7382 
   12000    -11088.53    -11088.53   -11259.334   -11259.334    330.43049    330.43049    68530.876    68530.876    364.35528    364.35528 
Loop time of 446.381 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.995 hours/ns, 2.240 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    | 445.28     | 445.28     | 445.28     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19272    | 0.19272    | 0.19272    |   0.0 |  0.04
Output  | 0.00018011 | 0.00018011 | 0.00018011 |   0.0 |  0.00
Modify  | 0.80013    | 0.80013    | 0.80013    |   0.0 |  0.18
Other   |            | 0.1064     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7177.00 ave        7177 max        7177 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:      548794.0 ave      548794 max      548794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548794
Ave neighs/atom = 137.19850
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 = 333.355147014895, Press = -4.46654611981652
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.474 | 5.474 | 5.474 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000    -11088.53    -11088.53   -11259.334   -11259.334    330.43049    330.43049    68530.876    68530.876    364.35528    364.35528 
   13000   -11086.807   -11086.807   -11256.827   -11256.827    328.91611    328.91611    68542.809    68542.809    297.82285    297.82285 
Loop time of 443.485 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.195 ns/day, 123.190 hours/ns, 2.255 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    | 442.39     | 442.39     | 442.39     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19161    | 0.19161    | 0.19161    |   0.0 |  0.04
Output  | 0.00018253 | 0.00018253 | 0.00018253 |   0.0 |  0.00
Modify  | 0.79724    | 0.79724    | 0.79724    |   0.0 |  0.18
Other   |            | 0.1062     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7171.00 ave        7171 max        7171 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:      548948.0 ave      548948 max      548948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548948
Ave neighs/atom = 137.23700
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 = 333.556473656983, Press = -0.515754529597757
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -11086.807   -11086.807   -11256.827   -11256.827    328.91611    328.91611    68542.809    68542.809    297.82285    297.82285 
   14000   -11081.694   -11081.694   -11256.775   -11256.775    338.70667    338.70667    68568.514    68568.514    102.76465    102.76465 
Loop time of 438.057 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.197 ns/day, 121.683 hours/ns, 2.283 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    | 436.98     | 436.98     | 436.98     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19036    | 0.19036    | 0.19036    |   0.0 |  0.04
Output  | 0.00018107 | 0.00018107 | 0.00018107 |   0.0 |  0.00
Modify  | 0.77748    | 0.77748    | 0.77748    |   0.0 |  0.18
Other   |            | 0.1062     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7143.00 ave        7143 max        7143 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:      548968.0 ave      548968 max      548968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548968
Ave neighs/atom = 137.24200
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 = 333.619736405068, Press = -0.296645285287261
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -11081.694   -11081.694   -11256.775   -11256.775    338.70667    338.70667    68568.514    68568.514    102.76465    102.76465 
   15000    -11082.94    -11082.94   -11256.679   -11256.679    336.10851    336.10851     68602.38     68602.38   -391.60265   -391.60265 
Loop time of 425.976 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.327 hours/ns, 2.348 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    | 424.94     | 424.94     | 424.94     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18385    | 0.18385    | 0.18385    |   0.0 |  0.04
Output  | 0.00048852 | 0.00048852 | 0.00048852 |   0.0 |  0.00
Modify  | 0.7518     | 0.7518     | 0.7518     |   0.0 |  0.18
Other   |            | 0.102      |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7074.00 ave        7074 max        7074 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:      548966.0 ave      548966 max      548966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548966
Ave neighs/atom = 137.24150
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 = 333.58317476637, Press = 3.70623969218775
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.472 | 5.472 | 5.472 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000    -11082.94    -11082.94   -11256.679   -11256.679    336.10851    336.10851     68602.38     68602.38   -391.60265   -391.60265 
   16000   -11086.326   -11086.326   -11255.054   -11255.054      326.416      326.416    68669.256    68669.256   -1354.1104   -1354.1104 
Loop time of 433.818 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.505 hours/ns, 2.305 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 432.77     | 432.77     | 432.77     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18228    | 0.18228    | 0.18228    |   0.0 |  0.04
Output  | 0.00024012 | 0.00024012 | 0.00024012 |   0.0 |  0.00
Modify  | 0.75907    | 0.75907    | 0.75907    |   0.0 |  0.17
Other   |            | 0.1044     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7015.00 ave        7015 max        7015 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:      548842.0 ave      548842 max      548842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548842
Ave neighs/atom = 137.21050
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 = 333.429845268269, Press = -2.3903943939701
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -11086.326   -11086.326   -11255.054   -11255.054      326.416      326.416    68669.256    68669.256   -1354.1104   -1354.1104 
   17000   -11089.702   -11089.702   -11259.333   -11259.333    328.16346    328.16346    68508.437    68508.437    895.08906    895.08906 
Loop time of 462.658 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.516 hours/ns, 2.161 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    | 461.52     | 461.52     | 461.52     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19253    | 0.19253    | 0.19253    |   0.0 |  0.04
Output  | 0.00028834 | 0.00028834 | 0.00028834 |   0.0 |  0.00
Modify  | 0.8389     | 0.8389     | 0.8389     |   0.0 |  0.18
Other   |            | 0.1093     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7061.00 ave        7061 max        7061 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:      548624.0 ave      548624 max      548624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548624
Ave neighs/atom = 137.15600
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 = 333.282263607308, Press = -1.85660030965181
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.474 | 5.474 | 5.474 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -11089.702   -11089.702   -11259.333   -11259.333    328.16346    328.16346    68508.437    68508.437    895.08906    895.08906 
   18000   -11088.036   -11088.036   -11260.136   -11260.136    332.93916    332.93916    68598.085    68598.085   -461.96318   -461.96318 
Loop time of 444.404 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.445 hours/ns, 2.250 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 443.32     | 443.32     | 443.32     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19003    | 0.19003    | 0.19003    |   0.0 |  0.04
Output  | 0.00017912 | 0.00017912 | 0.00017912 |   0.0 |  0.00
Modify  | 0.79051    | 0.79051    | 0.79051    |   0.0 |  0.18
Other   |            | 0.1063     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7207.00 ave        7207 max        7207 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:      549186.0 ave      549186 max      549186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 549186
Ave neighs/atom = 137.29650
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 = 333.359478662344, Press = 0.883301713310229
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -11088.036   -11088.036   -11260.136   -11260.136    332.93916    332.93916    68598.085    68598.085   -461.96318   -461.96318 
   19000   -11082.591   -11082.591   -11257.248   -11257.248    337.88546    337.88546    68538.962    68538.962    310.95854    310.95854 
Loop time of 442.041 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.195 ns/day, 122.789 hours/ns, 2.262 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    | 440.95     | 440.95     | 440.95     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18749    | 0.18749    | 0.18749    |   0.0 |  0.04
Output  | 0.00018142 | 0.00018142 | 0.00018142 |   0.0 |  0.00
Modify  | 0.79313    | 0.79313    | 0.79313    |   0.0 |  0.18
Other   |            | 0.1066     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7141.00 ave        7141 max        7141 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:      548734.0 ave      548734 max      548734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548734
Ave neighs/atom = 137.18350
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 = 333.422260790442, Press = -0.223124576521123
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.474 | 5.474 | 5.474 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -11082.591   -11082.591   -11257.248   -11257.248    337.88546    337.88546    68538.962    68538.962    310.95854    310.95854 
   20000   -11081.822   -11081.822   -11257.718   -11257.718    340.28198    340.28198    68606.578    68606.578   -501.46562   -501.46562 
Loop time of 426.435 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.454 hours/ns, 2.345 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 425.39     | 425.39     | 425.39     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18676    | 0.18676    | 0.18676    |   0.0 |  0.04
Output  | 0.00018165 | 0.00018165 | 0.00018165 |   0.0 |  0.00
Modify  | 0.75031    | 0.75031    | 0.75031    |   0.0 |  0.18
Other   |            | 0.1032     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7222.00 ave        7222 max        7222 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:      548928.0 ave      548928 max      548928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548928
Ave neighs/atom = 137.23200
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 = 333.433698245577, Press = 1.04167355552885
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.474 | 5.474 | 5.474 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -11081.822   -11081.822   -11257.718   -11257.718    340.28198    340.28198    68606.578    68606.578   -501.46562   -501.46562 
   21000   -11086.139   -11086.139   -11256.926   -11256.926    330.39846    330.39846    68666.447    68666.447   -1387.7925   -1387.7925 
Loop time of 450.679 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 125.189 hours/ns, 2.219 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 449.57     | 449.57     | 449.57     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19436    | 0.19436    | 0.19436    |   0.0 |  0.04
Output  | 0.00017994 | 0.00017994 | 0.00017994 |   0.0 |  0.00
Modify  | 0.80521    | 0.80521    | 0.80521    |   0.0 |  0.18
Other   |            | 0.1077     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7197.00 ave        7197 max        7197 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:      548720.0 ave      548720 max      548720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548720
Ave neighs/atom = 137.18000
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 = 333.464001788235, Press = -0.132958876607197
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.472 | 5.472 | 5.472 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -11086.139   -11086.139   -11256.926   -11256.926    330.39846    330.39846    68666.447    68666.447   -1387.7925   -1387.7925 
   22000   -11087.535   -11087.535   -11258.474   -11258.474      330.692      330.692    68524.563    68524.563    487.29742    487.29742 
Loop time of 451.241 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.191 ns/day, 125.345 hours/ns, 2.216 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    | 450.14     | 450.14     | 450.14     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18942    | 0.18942    | 0.18942    |   0.0 |  0.04
Output  | 0.00025999 | 0.00025999 | 0.00025999 |   0.0 |  0.00
Modify  | 0.81092    | 0.81092    | 0.81092    |   0.0 |  0.18
Other   |            | 0.1055     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7004.00 ave        7004 max        7004 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:      548564.0 ave      548564 max      548564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548564
Ave neighs/atom = 137.14100
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 = 333.527102700342, Press = -4.2002122888975
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -11087.535   -11087.535   -11258.474   -11258.474      330.692      330.692    68524.563    68524.563    487.29742    487.29742 
   23000   -11089.355   -11089.355   -11260.344   -11260.344    330.79085    330.79085    68497.025    68497.025    879.30917    879.30917 
Loop time of 460.839 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.011 hours/ns, 2.170 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    | 459.7      | 459.7      | 459.7      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19392    | 0.19392    | 0.19392    |   0.0 |  0.04
Output  | 0.00022823 | 0.00022823 | 0.00022823 |   0.0 |  0.00
Modify  | 0.83471    | 0.83471    | 0.83471    |   0.0 |  0.18
Other   |            | 0.1087     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7123.00 ave        7123 max        7123 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:      548998.0 ave      548998 max      548998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548998
Ave neighs/atom = 137.24950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.597258645105, Press = 0.0976460340141209
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -11089.355   -11089.355   -11260.344   -11260.344    330.79085    330.79085    68497.025    68497.025    879.30917    879.30917 
   24000   -11086.044   -11086.044   -11259.171   -11259.171    334.92644    334.92644    68584.731    68584.731   -213.43703   -213.43703 
Loop time of 460.244 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.846 hours/ns, 2.173 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    | 459.11     | 459.11     | 459.11     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19302    | 0.19302    | 0.19302    |   0.0 |  0.04
Output  | 0.00017667 | 0.00017667 | 0.00017667 |   0.0 |  0.00
Modify  | 0.83647    | 0.83647    | 0.83647    |   0.0 |  0.18
Other   |            | 0.1081     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7113.00 ave        7113 max        7113 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:      549142.0 ave      549142 max      549142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 549142
Ave neighs/atom = 137.28550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.526410938102, Press = 1.38998761512311
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -11086.044   -11086.044   -11259.171   -11259.171    334.92644    334.92644    68584.731    68584.731   -213.43703   -213.43703 
   25000   -11081.651   -11081.651   -11256.202   -11256.202    337.68154    337.68154    68655.139    68655.139   -1342.7025   -1342.7025 
Loop time of 455.178 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.190 ns/day, 126.438 hours/ns, 2.197 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    | 454.05     | 454.05     | 454.05     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19265    | 0.19265    | 0.19265    |   0.0 |  0.04
Output  | 0.00028077 | 0.00028077 | 0.00028077 |   0.0 |  0.00
Modify  | 0.82929    | 0.82929    | 0.82929    |   0.0 |  0.18
Other   |            | 0.1075     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7160.00 ave        7160 max        7160 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:      548872.0 ave      548872 max      548872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548872
Ave neighs/atom = 137.21800
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 = 333.538779372365, Press = -0.166921576678122
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -11081.651   -11081.651   -11256.202   -11256.202    337.68154    337.68154    68655.139    68655.139   -1342.7025   -1342.7025 
   26000   -11083.325   -11083.325   -11257.416   -11257.416    336.79194    336.79194    68558.221    68558.221    263.99786    263.99786 
Loop time of 447.97 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.436 hours/ns, 2.232 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    | 446.87     | 446.87     | 446.87     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19065    | 0.19065    | 0.19065    |   0.0 |  0.04
Output  | 0.00024247 | 0.00024247 | 0.00024247 |   0.0 |  0.00
Modify  | 0.80684    | 0.80684    | 0.80684    |   0.0 |  0.18
Other   |            | 0.1059     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7149.00 ave        7149 max        7149 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:      548686.0 ave      548686 max      548686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548686
Ave neighs/atom = 137.17150
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 = 333.58535874192, Press = -0.366887624535335
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.474 | 5.474 | 5.474 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -11083.325   -11083.325   -11257.416   -11257.416    336.79194    336.79194    68558.221    68558.221    263.99786    263.99786 
   27000    -11090.21    -11090.21   -11261.882   -11261.882    332.11216    332.11216    68576.676    68576.676   -236.99119   -236.99119 
Loop time of 460.181 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.828 hours/ns, 2.173 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    | 459.05     | 459.05     | 459.05     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19435    | 0.19435    | 0.19435    |   0.0 |  0.04
Output  | 0.00021928 | 0.00021928 | 0.00021928 |   0.0 |  0.00
Modify  | 0.82837    | 0.82837    | 0.82837    |   0.0 |  0.18
Other   |            | 0.1078     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7182.00 ave        7182 max        7182 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:      549000.0 ave      549000 max      549000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 549000
Ave neighs/atom = 137.25000
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 = 333.531280136582, Press = 0.65897651127877
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000    -11090.21    -11090.21   -11261.882   -11261.882    332.11216    332.11216    68576.676    68576.676   -236.99119   -236.99119 
   28000   -11083.473   -11083.473   -11257.267   -11257.267    336.21504    336.21504    68611.067    68611.067   -594.52091   -594.52091 
Loop time of 421.58 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 420.55     | 420.55     | 420.55     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18074    | 0.18074    | 0.18074    |   0.0 |  0.04
Output  | 0.00024142 | 0.00024142 | 0.00024142 |   0.0 |  0.00
Modify  | 0.74197    | 0.74197    | 0.74197    |   0.0 |  0.18
Other   |            | 0.1036     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7084.00 ave        7084 max        7084 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:      548908.0 ave      548908 max      548908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548908
Ave neighs/atom = 137.22700
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 = 333.590693219091, Press = -0.70922232253193
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.472 | 5.472 | 5.472 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -11083.473   -11083.473   -11257.267   -11257.267    336.21504    336.21504    68611.067    68611.067   -594.52091   -594.52091 
   29000   -11084.592   -11084.592   -11256.521   -11256.521     332.6079     332.6079     68564.41     68564.41    100.95478    100.95478 
Loop time of 446.143 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.929 hours/ns, 2.241 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 445.05     | 445.05     | 445.05     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18434    | 0.18434    | 0.18434    |   0.0 |  0.04
Output  | 0.00018009 | 0.00018009 | 0.00018009 |   0.0 |  0.00
Modify  | 0.8015     | 0.8015     | 0.8015     |   0.0 |  0.18
Other   |            | 0.1064     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6940.00 ave        6940 max        6940 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:      548798.0 ave      548798 max      548798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548798
Ave neighs/atom = 137.19950
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 = 333.54286634883, Press = -0.0825438306747018
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -11084.592   -11084.592   -11256.521   -11256.521     332.6079     332.6079     68564.41     68564.41    100.95478    100.95478 
   30000   -11086.153   -11086.153   -11255.621   -11255.621    327.84633    327.84633    68589.268    68589.268   -350.87507   -350.87507 
Loop time of 449.834 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 124.954 hours/ns, 2.223 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 448.74     | 448.74     | 448.74     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19024    | 0.19024    | 0.19024    |   0.0 |  0.04
Output  | 0.00018145 | 0.00018145 | 0.00018145 |   0.0 |  0.00
Modify  | 0.79689    | 0.79689    | 0.79689    |   0.0 |  0.18
Other   |            | 0.1074     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7057.00 ave        7057 max        7057 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:      548816.0 ave      548816 max      548816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548816
Ave neighs/atom = 137.20400
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 = 333.620537293407, Press = -1.19671522233178
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -11086.153   -11086.153   -11255.621   -11255.621    327.84633    327.84633    68589.268    68589.268   -350.87507   -350.87507 
   31000   -11082.922   -11082.922   -11255.676   -11255.676    334.20362    334.20362    68472.515    68472.515    1352.6704    1352.6704 
Loop time of 462.891 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.581 hours/ns, 2.160 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    | 461.75     | 461.75     | 461.75     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19587    | 0.19587    | 0.19587    |   0.0 |  0.04
Output  | 0.00018054 | 0.00018054 | 0.00018054 |   0.0 |  0.00
Modify  | 0.83419    | 0.83419    | 0.83419    |   0.0 |  0.18
Other   |            | 0.1107     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7078.00 ave        7078 max        7078 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:      548776.0 ave      548776 max      548776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548776
Ave neighs/atom = 137.19400
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 = 333.658280018962, Press = -0.516361487463561
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.474 | 5.474 | 5.474 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -11082.922   -11082.922   -11255.676   -11255.676    334.20362    334.20362    68472.515    68472.515    1352.6704    1352.6704 
   32000   -11082.214   -11082.214   -11257.562   -11257.562     339.2213     339.2213    68571.812    68571.812    96.903408    96.903408 
Loop time of 458.787 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.441 hours/ns, 2.180 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    | 457.66     | 457.66     | 457.66     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19557    | 0.19557    | 0.19557    |   0.0 |  0.04
Output  | 0.00026878 | 0.00026878 | 0.00026878 |   0.0 |  0.00
Modify  | 0.82073    | 0.82073    | 0.82073    |   0.0 |  0.18
Other   |            | 0.1086     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7212.00 ave        7212 max        7212 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:      549066.0 ave      549066 max      549066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 549066
Ave neighs/atom = 137.26650
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 = 333.63600923464, Press = 1.7854314092056
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.474 | 5.474 | 5.474 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -11082.214   -11082.214   -11257.562   -11257.562     339.2213     339.2213    68571.812    68571.812    96.903408    96.903408 
   33000   -11088.108   -11088.108   -11261.159   -11261.159    334.77802    334.77802    68632.071    68632.071   -994.22543   -994.22543 
Loop time of 462.754 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.543 hours/ns, 2.161 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    | 461.61     | 461.61     | 461.61     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19491    | 0.19491    | 0.19491    |   0.0 |  0.04
Output  | 0.00022552 | 0.00022552 | 0.00022552 |   0.0 |  0.00
Modify  | 0.84293    | 0.84293    | 0.84293    |   0.0 |  0.18
Other   |            | 0.1097     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7180.00 ave        7180 max        7180 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:      548954.0 ave      548954 max      548954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548954
Ave neighs/atom = 137.23850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.594787797494, Press = -0.224842808528148
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -11088.108   -11088.108   -11261.159   -11261.159    334.77802    334.77802    68632.071    68632.071   -994.22543   -994.22543 
   34000   -11090.675   -11090.675   -11262.327   -11262.327    332.07231    332.07231    68512.799    68512.799    837.44875    837.44875 
Loop time of 461.867 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.296 hours/ns, 2.165 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    | 460.73     | 460.73     | 460.73     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19339    | 0.19339    | 0.19339    |   0.0 |  0.04
Output  | 0.00021639 | 0.00021639 | 0.00021639 |   0.0 |  0.00
Modify  | 0.83748    | 0.83748    | 0.83748    |   0.0 |  0.18
Other   |            | 0.1093     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7114.00 ave        7114 max        7114 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:      548620.0 ave      548620 max      548620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548620
Ave neighs/atom = 137.15500
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 = 333.551733848117, Press = 0.0312166567511734
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.474 | 5.474 | 5.474 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -11090.675   -11090.675   -11262.327   -11262.327    332.07231    332.07231    68512.799    68512.799    837.44875    837.44875 
   35000   -11084.432   -11084.432   -11255.964   -11255.964     331.8398     331.8398    68589.101    68589.101    -350.4334    -350.4334 
Loop time of 461.181 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.106 hours/ns, 2.168 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    | 460.04     | 460.04     | 460.04     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19477    | 0.19477    | 0.19477    |   0.0 |  0.04
Output  | 0.0002394  | 0.0002394  | 0.0002394  |   0.0 |  0.00
Modify  | 0.84001    | 0.84001    | 0.84001    |   0.0 |  0.18
Other   |            | 0.1089     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7209.00 ave        7209 max        7209 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:      548904.0 ave      548904 max      548904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548904
Ave neighs/atom = 137.22600
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 = 333.475356440359, Press = 0.381987404599477
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -11084.432   -11084.432   -11255.964   -11255.964     331.8398     331.8398    68589.101    68589.101    -350.4334    -350.4334 
   36000   -11088.212   -11088.212   -11259.551   -11259.551    331.46801    331.46801    68607.286    68607.286    -480.9955    -480.9955 
Loop time of 461.311 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.142 hours/ns, 2.168 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    | 460.18     | 460.18     | 460.18     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19012    | 0.19012    | 0.19012    |   0.0 |  0.04
Output  | 0.00018108 | 0.00018108 | 0.00018108 |   0.0 |  0.00
Modify  | 0.8299     | 0.8299     | 0.8299     |   0.0 |  0.18
Other   |            | 0.1091     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7082.00 ave        7082 max        7082 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:      548964.0 ave      548964 max      548964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548964
Ave neighs/atom = 137.24100
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 = 333.44377162262, Press = 0.152352856865
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -11088.212   -11088.212   -11259.551   -11259.551    331.46801    331.46801    68607.286    68607.286    -480.9955    -480.9955 
   37000    -11088.11    -11088.11   -11260.626   -11260.626    333.74475    333.74475     68609.47     68609.47   -752.81659   -752.81659 
Loop time of 461.395 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.165 hours/ns, 2.167 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    | 460.25     | 460.25     | 460.25     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19253    | 0.19253    | 0.19253    |   0.0 |  0.04
Output  | 0.00017966 | 0.00017966 | 0.00017966 |   0.0 |  0.00
Modify  | 0.83846    | 0.83846    | 0.83846    |   0.0 |  0.18
Other   |            | 0.1103     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7069.00 ave        7069 max        7069 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:      548872.0 ave      548872 max      548872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548872
Ave neighs/atom = 137.21800
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 = 333.398497259678, Press = -1.05934157709231
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.2
  ghost atom cutoff = 8.2
  binsize = 4.1, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.2
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.473 | 5.473 | 5.473 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000    -11088.11    -11088.11   -11260.626   -11260.626    333.74475    333.74475     68609.47     68609.47   -752.81659   -752.81659 
   38000   -11084.516   -11084.516   -11259.156   -11259.156    337.85341    337.85341    68504.264    68504.264    910.86078    910.86078 
Loop time of 461.728 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.187 ns/day, 128.258 hours/ns, 2.166 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    | 460.59     | 460.59     | 460.59     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1938     | 0.1938     | 0.1938     |   0.0 |  0.04
Output  | 0.00018271 | 0.00018271 | 0.00018271 |   0.0 |  0.00
Modify  | 0.83852    | 0.83852    | 0.83852    |   0.0 |  0.18
Other   |            | 0.1101     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        7164.00 ave        7164 max        7164 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:      548810.0 ave      548810 max      548810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 548810
Ave neighs/atom = 137.20250
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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
68569.0836020023

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0