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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.5090000331401834*${_u_distance}
variable latticeconst_converted equal 3.5090000331401834*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.50900003314018
Lattice spacing in x,y,z = 3.5090000 3.5090000 3.5090000
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0.0000000 0.0000000 0.0000000) to (35.090000 35.090000 35.090000)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (35.090000 35.090000 35.090000)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Li

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

kim interactions Li
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_RoyDuttaChakraborti_2021_AlLi__MO_971738391444_000
pair_coeff * * Li
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 6.941

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0    -3213.917    -3213.917        -3300        -3300       333.15       333.15    43206.602    43206.602    2128.0681    2128.0681 
    1000   -3182.6456   -3182.6456   -3267.4935   -3267.4935    328.37001    328.37001    47430.167    47430.167    474.39743    474.39743 
Loop time of 91.8 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.941 ns/day, 25.500 hours/ns, 10.893 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    | 90.771     | 90.771     | 90.771     |   0.0 | 98.88
Neigh   | 0.52604    | 0.52604    | 0.52604    |   0.0 |  0.57
Comm    | 0.091858   | 0.091858   | 0.091858   |   0.0 |  0.10
Output  | 0.00020198 | 0.00020198 | 0.00020198 |   0.0 |  0.00
Modify  | 0.35566    | 0.35566    | 0.35566    |   0.0 |  0.39
Other   |            | 0.05504    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3294.00 ave        3294 max        3294 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:      118988.0 ave      118988 max      118988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118988
Ave neighs/atom = 59.494000
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -3182.6456   -3182.6456   -3267.4935   -3267.4935    328.37001    328.37001    47430.167    47430.167    474.39743    474.39743 
    2000   -3177.3992   -3177.3992   -3265.6266   -3265.6266    341.44929    341.44929    47608.954    47608.954   -21.804715   -21.804715 
Loop time of 91.8054 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.941 ns/day, 25.502 hours/ns, 10.893 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    | 90.751     | 90.751     | 90.751     |   0.0 | 98.85
Neigh   | 0.54806    | 0.54806    | 0.54806    |   0.0 |  0.60
Comm    | 0.093497   | 0.093497   | 0.093497   |   0.0 |  0.10
Output  | 0.00019024 | 0.00019024 | 0.00019024 |   0.0 |  0.00
Modify  | 0.35663    | 0.35663    | 0.35663    |   0.0 |  0.39
Other   |            | 0.05558    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3290.00 ave        3290 max        3290 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:      118854.0 ave      118854 max      118854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118854
Ave neighs/atom = 59.427000
Neighbor list builds = 25
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -3177.3992   -3177.3992   -3265.6266   -3265.6266    341.44929    341.44929    47608.954    47608.954   -21.804715   -21.804715 
    3000   -3178.7928   -3178.7928   -3265.7172   -3265.7172    336.40647    336.40647     47629.55     47629.55   -80.714196   -80.714196 
Loop time of 93.7644 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.921 ns/day, 26.046 hours/ns, 10.665 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 92.719     | 92.719     | 92.719     |   0.0 | 98.89
Neigh   | 0.52902    | 0.52902    | 0.52902    |   0.0 |  0.56
Comm    | 0.094335   | 0.094335   | 0.094335   |   0.0 |  0.10
Output  | 0.00019545 | 0.00019545 | 0.00019545 |   0.0 |  0.00
Modify  | 0.36581    | 0.36581    | 0.36581    |   0.0 |  0.39
Other   |            | 0.05585    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3219.00 ave        3219 max        3219 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:      118646.0 ave      118646 max      118646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118646
Ave neighs/atom = 59.323000
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -3178.7928   -3178.7928   -3265.7172   -3265.7172    336.40647    336.40647     47629.55     47629.55   -80.714196   -80.714196 
    4000   -3176.6394   -3176.6394   -3260.4606   -3260.4606    324.39656    324.39656    47769.054    47769.054   -155.84251   -155.84251 
Loop time of 93.6304 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.923 ns/day, 26.008 hours/ns, 10.680 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    | 92.577     | 92.577     | 92.577     |   0.0 | 98.88
Neigh   | 0.52892    | 0.52892    | 0.52892    |   0.0 |  0.56
Comm    | 0.095022   | 0.095022   | 0.095022   |   0.0 |  0.10
Output  | 0.00019131 | 0.00019131 | 0.00019131 |   0.0 |  0.00
Modify  | 0.37199    | 0.37199    | 0.37199    |   0.0 |  0.40
Other   |            | 0.05707    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3256.00 ave        3256 max        3256 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:      118502.0 ave      118502 max      118502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118502
Ave neighs/atom = 59.251000
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -3176.6394   -3176.6394   -3260.4606   -3260.4606    324.39656    324.39656    47769.054    47769.054   -155.84251   -155.84251 
    5000   -3173.7499   -3173.7499   -3260.9831   -3260.9831    337.60135    337.60135    47816.603    47816.603   -126.73017   -126.73017 
Loop time of 93.2051 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.927 ns/day, 25.890 hours/ns, 10.729 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    | 92.129     | 92.129     | 92.129     |   0.0 | 98.84
Neigh   | 0.55235    | 0.55235    | 0.55235    |   0.0 |  0.59
Comm    | 0.094851   | 0.094851   | 0.094851   |   0.0 |  0.10
Output  | 0.00015684 | 0.00015684 | 0.00015684 |   0.0 |  0.00
Modify  | 0.37268    | 0.37268    | 0.37268    |   0.0 |  0.40
Other   |            | 0.0565     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3230.00 ave        3230 max        3230 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:      118298.0 ave      118298 max      118298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118298
Ave neighs/atom = 59.149000
Neighbor list builds = 25
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 = 335.253365746892, Press = 123.170419485428
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -3173.7499   -3173.7499   -3260.9831   -3260.9831    337.60135    337.60135    47816.603    47816.603   -126.73017   -126.73017 
    6000   -3178.5649   -3178.5649   -3263.9531   -3263.9531     330.4612     330.4612    47876.816    47876.816    -176.1581    -176.1581 
Loop time of 93.6167 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.923 ns/day, 26.005 hours/ns, 10.682 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    | 92.526     | 92.526     | 92.526     |   0.0 | 98.83
Neigh   | 0.55025    | 0.55025    | 0.55025    |   0.0 |  0.59
Comm    | 0.095358   | 0.095358   | 0.095358   |   0.0 |  0.10
Output  | 0.00016217 | 0.00016217 | 0.00016217 |   0.0 |  0.00
Modify  | 0.3891     | 0.3891     | 0.3891     |   0.0 |  0.42
Other   |            | 0.05603    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3264.00 ave        3264 max        3264 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:      118214.0 ave      118214 max      118214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118214
Ave neighs/atom = 59.107000
Neighbor list builds = 25
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 = 330.834195924748, Press = 9.69887963626326
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -3178.5649   -3178.5649   -3263.9531   -3263.9531     330.4612     330.4612    47876.816    47876.816    -176.1581    -176.1581 
    7000   -3172.8863   -3172.8863   -3259.1931   -3259.1931     334.0164     334.0164    47857.269    47857.269   -315.61408   -315.61408 
Loop time of 93.3455 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.926 ns/day, 25.929 hours/ns, 10.713 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    | 92.271     | 92.271     | 92.271     |   0.0 | 98.85
Neigh   | 0.5337     | 0.5337     | 0.5337     |   0.0 |  0.57
Comm    | 0.094596   | 0.094596   | 0.094596   |   0.0 |  0.10
Output  | 0.00015971 | 0.00015971 | 0.00015971 |   0.0 |  0.00
Modify  | 0.39036    | 0.39036    | 0.39036    |   0.0 |  0.42
Other   |            | 0.05616    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3274.00 ave        3274 max        3274 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:      118208.0 ave      118208 max      118208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118208
Ave neighs/atom = 59.104000
Neighbor list builds = 24
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 = 330.924907594497, Press = -8.52243575088782
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -3172.8863   -3172.8863   -3259.1931   -3259.1931     334.0164     334.0164    47857.269    47857.269   -315.61408   -315.61408 
    8000    -3172.905    -3172.905   -3259.9127   -3259.9127     336.7288     336.7288    47829.887    47829.887   -67.645364   -67.645364 
Loop time of 92.7326 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.932 ns/day, 25.759 hours/ns, 10.784 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    | 91.659     | 91.659     | 91.659     |   0.0 | 98.84
Neigh   | 0.53407    | 0.53407    | 0.53407    |   0.0 |  0.58
Comm    | 0.095088   | 0.095088   | 0.095088   |   0.0 |  0.10
Output  | 0.0001589  | 0.0001589  | 0.0001589  |   0.0 |  0.00
Modify  | 0.38821    | 0.38821    | 0.38821    |   0.0 |  0.42
Other   |            | 0.05635    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3243.00 ave        3243 max        3243 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:      118282.0 ave      118282 max      118282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118282
Ave neighs/atom = 59.141000
Neighbor list builds = 24
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 = 331.379573307603, Press = -2.80963580089669
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000    -3172.905    -3172.905   -3259.9127   -3259.9127     336.7288     336.7288    47829.887    47829.887   -67.645364   -67.645364 
    9000   -3168.5476   -3168.5476   -3255.4269   -3255.4269    336.23213    336.23213    47936.705    47936.705   -37.471407   -37.471407 
Loop time of 92.7826 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.931 ns/day, 25.773 hours/ns, 10.778 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    | 91.706     | 91.706     | 91.706     |   0.0 | 98.84
Neigh   | 0.53443    | 0.53443    | 0.53443    |   0.0 |  0.58
Comm    | 0.09498    | 0.09498    | 0.09498    |   0.0 |  0.10
Output  | 0.00020208 | 0.00020208 | 0.00020208 |   0.0 |  0.00
Modify  | 0.39029    | 0.39029    | 0.39029    |   0.0 |  0.42
Other   |            | 0.05648    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3254.00 ave        3254 max        3254 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:      118094.0 ave      118094 max      118094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118094
Ave neighs/atom = 59.047000
Neighbor list builds = 24
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.069852591015, Press = 11.160881248175
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -3168.5476   -3168.5476   -3255.4269   -3255.4269    336.23213    336.23213    47936.705    47936.705   -37.471407   -37.471407 
   10000   -3167.8162   -3167.8162   -3256.8536   -3256.8536    344.58401    344.58401    48013.309    48013.309    -26.47854    -26.47854 
Loop time of 92.405 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.935 ns/day, 25.668 hours/ns, 10.822 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    | 91.306     | 91.306     | 91.306     |   0.0 | 98.81
Neigh   | 0.55825    | 0.55825    | 0.55825    |   0.0 |  0.60
Comm    | 0.095314   | 0.095314   | 0.095314   |   0.0 |  0.10
Output  | 0.0001586  | 0.0001586  | 0.0001586  |   0.0 |  0.00
Modify  | 0.38887    | 0.38887    | 0.38887    |   0.0 |  0.42
Other   |            | 0.05637    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3256.00 ave        3256 max        3256 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:      117840.0 ave      117840 max      117840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 117840
Ave neighs/atom = 58.920000
Neighbor list builds = 25
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.410906717258, Press = 10.9841147761619
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -3167.8162   -3167.8162   -3256.8536   -3256.8536    344.58401    344.58401    48013.309    48013.309    -26.47854    -26.47854 
   11000   -3171.0315   -3171.0315   -3255.5966   -3255.5966     327.2756     327.2756    48014.206    48014.206   -1.4976046   -1.4976046 
Loop time of 92.2068 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.937 ns/day, 25.613 hours/ns, 10.845 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    | 91.13      | 91.13      | 91.13      |   0.0 | 98.83
Neigh   | 0.5306     | 0.5306     | 0.5306     |   0.0 |  0.58
Comm    | 0.095822   | 0.095822   | 0.095822   |   0.0 |  0.10
Output  | 0.00015611 | 0.00015611 | 0.00015611 |   0.0 |  0.00
Modify  | 0.39315    | 0.39315    | 0.39315    |   0.0 |  0.43
Other   |            | 0.05709    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3289.00 ave        3289 max        3289 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:      117590.0 ave      117590 max      117590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 117590
Ave neighs/atom = 58.795000
Neighbor list builds = 24
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.334867961886, Press = -0.94835632085193
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -3171.0315   -3171.0315   -3255.5966   -3255.5966     327.2756     327.2756    48014.206    48014.206   -1.4976046   -1.4976046 
   12000   -3164.5604   -3164.5604   -3252.1424   -3252.1424    338.95136    338.95136     48371.22     48371.22   -377.33277   -377.33277 
Loop time of 89.7088 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.963 ns/day, 24.919 hours/ns, 11.147 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    | 88.671     | 88.671     | 88.671     |   0.0 | 98.84
Neigh   | 0.50222    | 0.50222    | 0.50222    |   0.0 |  0.56
Comm    | 0.094505   | 0.094505   | 0.094505   |   0.0 |  0.11
Output  | 0.00018346 | 0.00018346 | 0.00018346 |   0.0 |  0.00
Modify  | 0.3849     | 0.3849     | 0.3849     |   0.0 |  0.43
Other   |            | 0.05618    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3309.00 ave        3309 max        3309 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:      116698.0 ave      116698 max      116698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116698
Ave neighs/atom = 58.349000
Neighbor list builds = 23
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.670536264589, Press = -2.2553108375938
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -3164.5604   -3164.5604   -3252.1424   -3252.1424    338.95136    338.95136     48371.22     48371.22   -377.33277   -377.33277 
   13000   -3161.7848   -3161.7848    -3250.102    -3250.102    341.79659    341.79659    48361.915    48361.915   -176.82503   -176.82503 
Loop time of 92.1882 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.937 ns/day, 25.608 hours/ns, 10.847 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    | 91.099     | 91.099     | 91.099     |   0.0 | 98.82
Neigh   | 0.54004    | 0.54004    | 0.54004    |   0.0 |  0.59
Comm    | 0.095503   | 0.095503   | 0.095503   |   0.0 |  0.10
Output  | 0.0002364  | 0.0002364  | 0.0002364  |   0.0 |  0.00
Modify  | 0.3965     | 0.3965     | 0.3965     |   0.0 |  0.43
Other   |            | 0.05711    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3199.00 ave        3199 max        3199 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:      116462.0 ave      116462 max      116462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116462
Ave neighs/atom = 58.231000
Neighbor list builds = 24
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.58365605417, Press = -2.38631281066529
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -3161.7848   -3161.7848    -3250.102    -3250.102    341.79659    341.79659    48361.915    48361.915   -176.82503   -176.82503 
   14000   -3160.8812   -3160.8812   -3246.8401   -3246.8401    332.67008    332.67008    48478.479    48478.479   -113.63631   -113.63631 
Loop time of 87.6254 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.986 ns/day, 24.340 hours/ns, 11.412 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    | 86.574     | 86.574     | 86.574     |   0.0 | 98.80
Neigh   | 0.52466    | 0.52466    | 0.52466    |   0.0 |  0.60
Comm    | 0.092896   | 0.092896   | 0.092896   |   0.0 |  0.11
Output  | 0.00021733 | 0.00021733 | 0.00021733 |   0.0 |  0.00
Modify  | 0.3781     | 0.3781     | 0.3781     |   0.0 |  0.43
Other   |            | 0.05555    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3293.00 ave        3293 max        3293 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:      116138.0 ave      116138 max      116138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116138
Ave neighs/atom = 58.069000
Neighbor list builds = 24
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.665505965435, Press = 1.20302591352687
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -3160.8812   -3160.8812   -3246.8401   -3246.8401    332.67008    332.67008    48478.479    48478.479   -113.63631   -113.63631 
   15000   -3161.5425   -3161.5425    -3244.947    -3244.947    322.78422    322.78422    48391.417    48391.417    223.92388    223.92388 
Loop time of 88.8176 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.973 ns/day, 24.672 hours/ns, 11.259 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    | 87.739     | 87.739     | 87.739     |   0.0 | 98.79
Neigh   | 0.53348    | 0.53348    | 0.53348    |   0.0 |  0.60
Comm    | 0.095738   | 0.095738   | 0.095738   |   0.0 |  0.11
Output  | 0.00018865 | 0.00018865 | 0.00018865 |   0.0 |  0.00
Modify  | 0.39245    | 0.39245    | 0.39245    |   0.0 |  0.44
Other   |            | 0.05679    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3270.00 ave        3270 max        3270 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:      116152.0 ave      116152 max      116152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116152
Ave neighs/atom = 58.076000
Neighbor list builds = 24
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.607007358713, Press = 2.11232720952029
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -3161.5425   -3161.5425    -3244.947    -3244.947    322.78422    322.78422    48391.417    48391.417    223.92388    223.92388 
   16000   -3156.2207   -3156.2207   -3242.6121   -3242.6121    334.34355    334.34355    48818.322    48818.322   -403.12199   -403.12199 
Loop time of 87.2679 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.990 ns/day, 24.241 hours/ns, 11.459 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    | 86.182     | 86.182     | 86.182     |   0.0 | 98.76
Neigh   | 0.54727    | 0.54727    | 0.54727    |   0.0 |  0.63
Comm    | 0.095318   | 0.095318   | 0.095318   |   0.0 |  0.11
Output  | 0.0001661  | 0.0001661  | 0.0001661  |   0.0 |  0.00
Modify  | 0.38697    | 0.38697    | 0.38697    |   0.0 |  0.44
Other   |            | 0.05586    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3273.00 ave        3273 max        3273 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:      115166.0 ave      115166 max      115166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115166
Ave neighs/atom = 57.583000
Neighbor list builds = 25
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.664343254026, Press = -0.251419090391902
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -3156.2207   -3156.2207   -3242.6121   -3242.6121    334.34355    334.34355    48818.322    48818.322   -403.12199   -403.12199 
   17000   -3157.6028   -3157.6028   -3241.8947   -3241.8947    326.21837    326.21837    48946.604    48946.604   -588.27603   -588.27603 
Loop time of 87.5899 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.986 ns/day, 24.331 hours/ns, 11.417 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    | 86.519     | 86.519     | 86.519     |   0.0 | 98.78
Neigh   | 0.53089    | 0.53089    | 0.53089    |   0.0 |  0.61
Comm    | 0.094906   | 0.094906   | 0.094906   |   0.0 |  0.11
Output  | 0.00015974 | 0.00015974 | 0.00015974 |   0.0 |  0.00
Modify  | 0.38827    | 0.38827    | 0.38827    |   0.0 |  0.44
Other   |            | 0.05666    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3274.00 ave        3274 max        3274 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:      115096.0 ave      115096 max      115096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115096
Ave neighs/atom = 57.548000
Neighbor list builds = 24
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.454337411292, Press = 1.58825516536877
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -3157.6028   -3157.6028   -3241.8947   -3241.8947    326.21837    326.21837    48946.604    48946.604   -588.27603   -588.27603 
   18000   -3158.0644   -3158.0644   -3242.5113   -3242.5113    326.81789    326.81789    48824.572    48824.572   -361.92949   -361.92949 
Loop time of 87.9348 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.983 ns/day, 24.426 hours/ns, 11.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    | 86.848     | 86.848     | 86.848     |   0.0 | 98.76
Neigh   | 0.54829    | 0.54829    | 0.54829    |   0.0 |  0.62
Comm    | 0.095472   | 0.095472   | 0.095472   |   0.0 |  0.11
Output  | 0.00015828 | 0.00015828 | 0.00015828 |   0.0 |  0.00
Modify  | 0.3872     | 0.3872     | 0.3872     |   0.0 |  0.44
Other   |            | 0.05583    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3311.00 ave        3311 max        3311 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:      115170.0 ave      115170 max      115170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115170
Ave neighs/atom = 57.585000
Neighbor list builds = 25
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.509115635139, Press = 0.959547370059858
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -3158.0644   -3158.0644   -3242.5113   -3242.5113    326.81789    326.81789    48824.572    48824.572   -361.92949   -361.92949 
   19000   -3156.8487   -3156.8487   -3240.8192   -3240.8192    324.97456    324.97456    48682.092    48682.092    126.13636    126.13636 
Loop time of 87.1524 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.991 ns/day, 24.209 hours/ns, 11.474 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    | 86.087     | 86.087     | 86.087     |   0.0 | 98.78
Neigh   | 0.52271    | 0.52271    | 0.52271    |   0.0 |  0.60
Comm    | 0.095542   | 0.095542   | 0.095542   |   0.0 |  0.11
Output  | 0.00024731 | 0.00024731 | 0.00024731 |   0.0 |  0.00
Modify  | 0.39021    | 0.39021    | 0.39021    |   0.0 |  0.45
Other   |            | 0.05703    |            |       |  0.07

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3299.00 ave        3299 max        3299 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:      115412.0 ave      115412 max      115412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115412
Ave neighs/atom = 57.706000
Neighbor list builds = 24
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.696576991643, Press = -1.14239598850044
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -3156.8487   -3156.8487   -3240.8192   -3240.8192    324.97456    324.97456    48682.092    48682.092    126.13636    126.13636 
   20000   -3151.4427   -3151.4427   -3238.8297   -3238.8297    338.19653    338.19653    48935.155    48935.155   -194.83602   -194.83602 
Loop time of 88.9865 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.971 ns/day, 24.718 hours/ns, 11.238 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    | 87.933     | 87.933     | 87.933     |   0.0 | 98.82
Neigh   | 0.50163    | 0.50163    | 0.50163    |   0.0 |  0.56
Comm    | 0.097044   | 0.097044   | 0.097044   |   0.0 |  0.11
Output  | 0.0002635  | 0.0002635  | 0.0002635  |   0.0 |  0.00
Modify  | 0.39756    | 0.39756    | 0.39756    |   0.0 |  0.45
Other   |            | 0.05692    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3322.00 ave        3322 max        3322 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:      114730.0 ave      114730 max      114730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 114730
Ave neighs/atom = 57.365000
Neighbor list builds = 23
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.847759460147, Press = -1.25599925514645
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -3151.4427   -3151.4427   -3238.8297   -3238.8297    338.19653    338.19653    48935.155    48935.155   -194.83602   -194.83602 
   21000   -3154.6893   -3154.6893   -3240.7729   -3240.7729     333.1526     333.1526    48873.943    48873.943    75.000095    75.000095 
Loop time of 88.4993 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.976 ns/day, 24.583 hours/ns, 11.300 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    | 87.418     | 87.418     | 87.418     |   0.0 | 98.78
Neigh   | 0.52657    | 0.52657    | 0.52657    |   0.0 |  0.59
Comm    | 0.096722   | 0.096722   | 0.096722   |   0.0 |  0.11
Output  | 0.00015892 | 0.00015892 | 0.00015892 |   0.0 |  0.00
Modify  | 0.40035    | 0.40035    | 0.40035    |   0.0 |  0.45
Other   |            | 0.05704    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3287.00 ave        3287 max        3287 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:      114994.0 ave      114994 max      114994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 114994
Ave neighs/atom = 57.497000
Neighbor list builds = 24
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.974166163832, Press = 1.07679216689729
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -3154.6893   -3154.6893   -3240.7729   -3240.7729     333.1526     333.1526    48873.943    48873.943    75.000095    75.000095 
   22000   -3151.4317   -3151.4317   -3238.3846   -3238.3846    336.51657    336.51657     48955.09     48955.09   -224.40649   -224.40649 
Loop time of 88.5686 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.976 ns/day, 24.602 hours/ns, 11.291 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    | 87.488     | 87.488     | 87.488     |   0.0 | 98.78
Neigh   | 0.52696    | 0.52696    | 0.52696    |   0.0 |  0.59
Comm    | 0.096891   | 0.096891   | 0.096891   |   0.0 |  0.11
Output  | 0.00020348 | 0.00020348 | 0.00020348 |   0.0 |  0.00
Modify  | 0.3994     | 0.3994     | 0.3994     |   0.0 |  0.45
Other   |            | 0.05706    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3309.00 ave        3309 max        3309 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:      115164.0 ave      115164 max      115164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115164
Ave neighs/atom = 57.582000
Neighbor list builds = 24
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.113824623425, Press = 1.63143104457162
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -3151.4317   -3151.4317   -3238.3846   -3238.3846    336.51657    336.51657     48955.09     48955.09   -224.40649   -224.40649 
   23000   -3160.1144   -3160.1144   -3245.5121   -3245.5121    330.49808    330.49808     48722.12     48722.12   -100.78725   -100.78725 
Loop time of 86.9827 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.993 ns/day, 24.162 hours/ns, 11.497 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    | 85.942     | 85.942     | 85.942     |   0.0 | 98.80
Neigh   | 0.50588    | 0.50588    | 0.50588    |   0.0 |  0.58
Comm    | 0.094426   | 0.094426   | 0.094426   |   0.0 |  0.11
Output  | 0.00016012 | 0.00016012 | 0.00016012 |   0.0 |  0.00
Modify  | 0.38434    | 0.38434    | 0.38434    |   0.0 |  0.44
Other   |            | 0.0562     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3273.00 ave        3273 max        3273 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:      115170.0 ave      115170 max      115170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115170
Ave neighs/atom = 57.585000
Neighbor list builds = 23
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.109106437291, Press = -0.393092709173864
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -3160.1144   -3160.1144   -3245.5121   -3245.5121    330.49808    330.49808     48722.12     48722.12   -100.78725   -100.78725 
   24000   -3156.6981   -3156.6981   -3242.1048   -3242.1048    330.53284    330.53284    48800.358    48800.358   -46.771372   -46.771372 
Loop time of 87.2559 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.990 ns/day, 24.238 hours/ns, 11.461 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    | 86.184     | 86.184     | 86.184     |   0.0 | 98.77
Neigh   | 0.53088    | 0.53088    | 0.53088    |   0.0 |  0.61
Comm    | 0.095085   | 0.095085   | 0.095085   |   0.0 |  0.11
Output  | 0.00016091 | 0.00016091 | 0.00016091 |   0.0 |  0.00
Modify  | 0.38835    | 0.38835    | 0.38835    |   0.0 |  0.45
Other   |            | 0.05695    |            |       |  0.07

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3324.00 ave        3324 max        3324 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:      115144.0 ave      115144 max      115144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115144
Ave neighs/atom = 57.572000
Neighbor list builds = 24
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.172127951299, Press = 0.362903363385805
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -3156.6981   -3156.6981   -3242.1048   -3242.1048    330.53284    330.53284    48800.358    48800.358   -46.771372   -46.771372 
   25000   -3157.9736   -3157.9736   -3242.6012   -3242.6012    327.51782    327.51782    48984.651    48984.651   -515.05757   -515.05757 
Loop time of 87.0332 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.993 ns/day, 24.176 hours/ns, 11.490 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    | 85.98      | 85.98      | 85.98      |   0.0 | 98.79
Neigh   | 0.51309    | 0.51309    | 0.51309    |   0.0 |  0.59
Comm    | 0.095298   | 0.095298   | 0.095298   |   0.0 |  0.11
Output  | 0.00025783 | 0.00025783 | 0.00025783 |   0.0 |  0.00
Modify  | 0.38808    | 0.38808    | 0.38808    |   0.0 |  0.45
Other   |            | 0.05615    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3280.00 ave        3280 max        3280 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:      114704.0 ave      114704 max      114704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 114704
Ave neighs/atom = 57.352000
Neighbor list builds = 24
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.197787537042, Press = -0.59345834185543
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -3157.9736   -3157.9736   -3242.6012   -3242.6012    327.51782    327.51782    48984.651    48984.651   -515.05757   -515.05757 
   26000   -3153.5183   -3153.5183   -3239.1863   -3239.1863    331.54419    331.54419     49023.64     49023.64   -486.53918   -486.53918 
Loop time of 86.9134 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.994 ns/day, 24.143 hours/ns, 11.506 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    | 85.849     | 85.849     | 85.849     |   0.0 | 98.78
Neigh   | 0.52171    | 0.52171    | 0.52171    |   0.0 |  0.60
Comm    | 0.094989   | 0.094989   | 0.094989   |   0.0 |  0.11
Output  | 0.0001581  | 0.0001581  | 0.0001581  |   0.0 |  0.00
Modify  | 0.39011    | 0.39011    | 0.39011    |   0.0 |  0.45
Other   |            | 0.05711    |            |       |  0.07

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3260.00 ave        3260 max        3260 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:      114744.0 ave      114744 max      114744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 114744
Ave neighs/atom = 57.372000
Neighbor list builds = 24
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.099205330711, Press = -0.778097570733794
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -3153.5183   -3153.5183   -3239.1863   -3239.1863    331.54419    331.54419     49023.64     49023.64   -486.53918   -486.53918 
   27000   -3155.9289   -3155.9289   -3241.5547   -3241.5547    331.38062    331.38062    48912.797    48912.797   -541.40375   -541.40375 
Loop time of 87.4718 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.988 ns/day, 24.298 hours/ns, 11.432 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    | 86.386     | 86.386     | 86.386     |   0.0 | 98.76
Neigh   | 0.54267    | 0.54267    | 0.54267    |   0.0 |  0.62
Comm    | 0.09596    | 0.09596    | 0.09596    |   0.0 |  0.11
Output  | 0.00015667 | 0.00015667 | 0.00015667 |   0.0 |  0.00
Modify  | 0.39121    | 0.39121    | 0.39121    |   0.0 |  0.45
Other   |            | 0.05622    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3268.00 ave        3268 max        3268 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:      114852.0 ave      114852 max      114852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 114852
Ave neighs/atom = 57.426000
Neighbor list builds = 25
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.225469806873, Press = -1.51931224801102
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -3155.9289   -3155.9289   -3241.5547   -3241.5547    331.38062    331.38062    48912.797    48912.797   -541.40375   -541.40375 
   28000   -3159.2359   -3159.2359   -3244.6499   -3244.6499    330.56117    330.56117    48879.192    48879.192   -404.36522   -404.36522 
Loop time of 88.9574 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.971 ns/day, 24.710 hours/ns, 11.241 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    | 87.88      | 87.88      | 87.88      |   0.0 | 98.79
Neigh   | 0.52535    | 0.52535    | 0.52535    |   0.0 |  0.59
Comm    | 0.09651    | 0.09651    | 0.09651    |   0.0 |  0.11
Output  | 0.0002396  | 0.0002396  | 0.0002396  |   0.0 |  0.00
Modify  | 0.39801    | 0.39801    | 0.39801    |   0.0 |  0.45
Other   |            | 0.05687    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3302.00 ave        3302 max        3302 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:      114938.0 ave      114938 max      114938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 114938
Ave neighs/atom = 57.469000
Neighbor list builds = 24
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.085282147896, Press = -0.779415991304083
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -3159.2359   -3159.2359   -3244.6499   -3244.6499    330.56117    330.56117    48879.192    48879.192   -404.36522   -404.36522 
   29000   -3153.2682   -3153.2682      -3239.9      -3239.9    335.27433    335.27433    48926.732    48926.732    -190.2865    -190.2865 
Loop time of 86.0839 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.004 ns/day, 23.912 hours/ns, 11.617 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    | 85.037     | 85.037     | 85.037     |   0.0 | 98.78
Neigh   | 0.51664    | 0.51664    | 0.51664    |   0.0 |  0.60
Comm    | 0.094027   | 0.094027   | 0.094027   |   0.0 |  0.11
Output  | 0.00015993 | 0.00015993 | 0.00015993 |   0.0 |  0.00
Modify  | 0.38029    | 0.38029    | 0.38029    |   0.0 |  0.44
Other   |            | 0.05616    |            |       |  0.07

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3272.00 ave        3272 max        3272 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:      115116.0 ave      115116 max      115116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115116
Ave neighs/atom = 57.558000
Neighbor list builds = 24
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.038805893641, Press = 0.388227493876521
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -3153.2682   -3153.2682      -3239.9      -3239.9    335.27433    335.27433    48926.732    48926.732    -190.2865    -190.2865 
   30000   -3154.6989   -3154.6989   -3241.2141   -3241.2141    334.82305    334.82305    48748.465    48748.465    86.075681    86.075681 
Loop time of 87.0174 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.993 ns/day, 24.172 hours/ns, 11.492 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    | 85.955     | 85.955     | 85.955     |   0.0 | 98.78
Neigh   | 0.52058    | 0.52058    | 0.52058    |   0.0 |  0.60
Comm    | 0.095031   | 0.095031   | 0.095031   |   0.0 |  0.11
Output  | 0.00019845 | 0.00019845 | 0.00019845 |   0.0 |  0.00
Modify  | 0.39046    | 0.39046    | 0.39046    |   0.0 |  0.45
Other   |            | 0.0564     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3288.00 ave        3288 max        3288 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:      115188.0 ave      115188 max      115188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115188
Ave neighs/atom = 57.594000
Neighbor list builds = 24
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.107188477086, Press = -0.327245508229243
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -3154.6989   -3154.6989   -3241.2141   -3241.2141    334.82305    334.82305    48748.465    48748.465    86.075681    86.075681 
   31000   -3155.9636   -3155.9636   -3241.9546   -3241.9546     332.7941     332.7941    48690.296    48690.296    147.72268    147.72268 
Loop time of 87.5699 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.987 ns/day, 24.325 hours/ns, 11.419 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    | 86.505     | 86.505     | 86.505     |   0.0 | 98.78
Neigh   | 0.52091    | 0.52091    | 0.52091    |   0.0 |  0.59
Comm    | 0.095622   | 0.095622   | 0.095622   |   0.0 |  0.11
Output  | 0.00015705 | 0.00015705 | 0.00015705 |   0.0 |  0.00
Modify  | 0.39157    | 0.39157    | 0.39157    |   0.0 |  0.45
Other   |            | 0.0565     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3316.00 ave        3316 max        3316 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:      115120.0 ave      115120 max      115120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115120
Ave neighs/atom = 57.560000
Neighbor list builds = 24
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.110948561082, Press = -1.49906984125696
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -3155.9636   -3155.9636   -3241.9546   -3241.9546     332.7941     332.7941    48690.296    48690.296    147.72268    147.72268 
   32000   -3151.7599   -3151.7599   -3240.2878   -3240.2878    342.61208    342.61208    48826.732    48826.732   -74.359726   -74.359726 
Loop time of 85.6736 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.008 ns/day, 23.798 hours/ns, 11.672 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    | 84.627     | 84.627     | 84.627     |   0.0 | 98.78
Neigh   | 0.51863    | 0.51863    | 0.51863    |   0.0 |  0.61
Comm    | 0.093746   | 0.093746   | 0.093746   |   0.0 |  0.11
Output  | 0.00016013 | 0.00016013 | 0.00016013 |   0.0 |  0.00
Modify  | 0.3782     | 0.3782     | 0.3782     |   0.0 |  0.44
Other   |            | 0.05637    |            |       |  0.07

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3290.00 ave        3290 max        3290 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:      115084.0 ave      115084 max      115084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115084
Ave neighs/atom = 57.542000
Neighbor list builds = 24
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.092565000452, Press = -1.1005450023859
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -3151.7599   -3151.7599   -3240.2878   -3240.2878    342.61208    342.61208    48826.732    48826.732   -74.359726   -74.359726 
   33000   -3155.3878   -3155.3878   -3242.6718   -3242.6718    337.79797    337.79797    48698.465    48698.465   -22.561258   -22.561258 
Loop time of 86.2322 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.002 ns/day, 23.953 hours/ns, 11.597 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    | 85.182     | 85.182     | 85.182     |   0.0 | 98.78
Neigh   | 0.51388    | 0.51388    | 0.51388    |   0.0 |  0.60
Comm    | 0.094934   | 0.094934   | 0.094934   |   0.0 |  0.11
Output  | 0.00015781 | 0.00015781 | 0.00015781 |   0.0 |  0.00
Modify  | 0.38499    | 0.38499    | 0.38499    |   0.0 |  0.45
Other   |            | 0.05627    |            |       |  0.07

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3339.00 ave        3339 max        3339 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:      115278.0 ave      115278 max      115278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115278
Ave neighs/atom = 57.639000
Neighbor list builds = 24
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.10836966527, Press = -0.396473692166323
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -3155.3878   -3155.3878   -3242.6718   -3242.6718    337.79797    337.79797    48698.465    48698.465   -22.561258   -22.561258 
   34000   -3157.2343   -3157.2343   -3242.2926   -3242.2926    329.18423    329.18423    48761.972    48761.972    256.74744    256.74744 
Loop time of 88.075 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.981 ns/day, 24.465 hours/ns, 11.354 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    | 87.007     | 87.007     | 87.007     |   0.0 | 98.79
Neigh   | 0.51743    | 0.51743    | 0.51743    |   0.0 |  0.59
Comm    | 0.095785   | 0.095785   | 0.095785   |   0.0 |  0.11
Output  | 0.00015796 | 0.00015796 | 0.00015796 |   0.0 |  0.00
Modify  | 0.39739    | 0.39739    | 0.39739    |   0.0 |  0.45
Other   |            | 0.05714    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3267.00 ave        3267 max        3267 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:      114812.0 ave      114812 max      114812 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 114812
Ave neighs/atom = 57.406000
Neighbor list builds = 24
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.093971559183, Press = -1.64277856214377
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -3157.2343   -3157.2343   -3242.2926   -3242.2926    329.18423    329.18423    48761.972    48761.972    256.74744    256.74744 
   35000   -3154.7823   -3154.7823   -3239.0089   -3239.0089    325.96549    325.96549    48573.669    48573.669    374.89682    374.89682 
Loop time of 87.3447 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.989 ns/day, 24.262 hours/ns, 11.449 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    | 86.268     | 86.268     | 86.268     |   0.0 | 98.77
Neigh   | 0.52889    | 0.52889    | 0.52889    |   0.0 |  0.61
Comm    | 0.095554   | 0.095554   | 0.095554   |   0.0 |  0.11
Output  | 0.00016002 | 0.00016002 | 0.00016002 |   0.0 |  0.00
Modify  | 0.39467    | 0.39467    | 0.39467    |   0.0 |  0.45
Other   |            | 0.05725    |            |       |  0.07

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3270.00 ave        3270 max        3270 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:      115794.0 ave      115794 max      115794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115794
Ave neighs/atom = 57.897000
Neighbor list builds = 24
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.069946835882, Press = -0.63658215507435
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -3154.7823   -3154.7823   -3239.0089   -3239.0089    325.96549    325.96549    48573.669    48573.669    374.89682    374.89682 
   36000   -3154.5373   -3154.5373   -3239.5215   -3239.5215    328.89752    328.89752    48607.902    48607.902    293.58931    293.58931 
Loop time of 88.6394 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.975 ns/day, 24.622 hours/ns, 11.282 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    | 87.532     | 87.532     | 87.532     |   0.0 | 98.75
Neigh   | 0.5542     | 0.5542     | 0.5542     |   0.0 |  0.63
Comm    | 0.096625   | 0.096625   | 0.096625   |   0.0 |  0.11
Output  | 0.00015897 | 0.00015897 | 0.00015897 |   0.0 |  0.00
Modify  | 0.39947    | 0.39947    | 0.39947    |   0.0 |  0.45
Other   |            | 0.05732    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3293.00 ave        3293 max        3293 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:      115568.0 ave      115568 max      115568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115568
Ave neighs/atom = 57.784000
Neighbor list builds = 25
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.003399499695, Press = -0.276174123712784
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -3154.5373   -3154.5373   -3239.5215   -3239.5215    328.89752    328.89752    48607.902    48607.902    293.58931    293.58931 
   37000   -3150.8736   -3150.8736   -3238.0881   -3238.0881    337.52909    337.52909    48602.176    48602.176    420.88466    420.88466 
Loop time of 85.0304 on 1 procs for 1000 steps with 2000 atoms

Performance: 1.016 ns/day, 23.620 hours/ns, 11.761 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    | 83.992     | 83.992     | 83.992     |   0.0 | 98.78
Neigh   | 0.51362    | 0.51362    | 0.51362    |   0.0 |  0.60
Comm    | 0.092759   | 0.092759   | 0.092759   |   0.0 |  0.11
Output  | 0.00015883 | 0.00015883 | 0.00015883 |   0.0 |  0.00
Modify  | 0.37641    | 0.37641    | 0.37641    |   0.0 |  0.44
Other   |            | 0.05516    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3299.00 ave        3299 max        3299 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:      115302.0 ave      115302 max      115302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115302
Ave neighs/atom = 57.651000
Neighbor list builds = 24
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.951709181968, Press = -1.33480219897113
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -3150.8736   -3150.8736   -3238.0881   -3238.0881    337.52909    337.52909    48602.176    48602.176    420.88466    420.88466 
   38000     -3154.42     -3154.42     -3242.84     -3242.84    342.19435    342.19435    48647.355    48647.355    190.13136    190.13136 
Loop time of 86.4876 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.999 ns/day, 24.024 hours/ns, 11.562 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    | 85.425     | 85.425     | 85.425     |   0.0 | 98.77
Neigh   | 0.52654    | 0.52654    | 0.52654    |   0.0 |  0.61
Comm    | 0.094977   | 0.094977   | 0.094977   |   0.0 |  0.11
Output  | 0.00016154 | 0.00016154 | 0.00016154 |   0.0 |  0.00
Modify  | 0.38521    | 0.38521    | 0.38521    |   0.0 |  0.45
Other   |            | 0.05598    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3315.00 ave        3315 max        3315 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:      115152.0 ave      115152 max      115152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115152
Ave neighs/atom = 57.576000
Neighbor list builds = 24
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.962984093258, Press = 0.264154914167621
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000     -3154.42     -3154.42     -3242.84     -3242.84    342.19435    342.19435    48647.355    48647.355    190.13136    190.13136 
   39000   -3153.3381   -3153.3381   -3240.1569   -3240.1569    335.99772    335.99772    48773.271    48773.271    -80.51635    -80.51635 
Loop time of 87.1834 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.991 ns/day, 24.218 hours/ns, 11.470 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    | 86.114     | 86.114     | 86.114     |   0.0 | 98.77
Neigh   | 0.52529    | 0.52529    | 0.52529    |   0.0 |  0.60
Comm    | 0.096048   | 0.096048   | 0.096048   |   0.0 |  0.11
Output  | 0.00019539 | 0.00019539 | 0.00019539 |   0.0 |  0.00
Modify  | 0.39131    | 0.39131    | 0.39131    |   0.0 |  0.45
Other   |            | 0.05642    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3315.00 ave        3315 max        3315 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:      115470.0 ave      115470 max      115470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115470
Ave neighs/atom = 57.735000
Neighbor list builds = 24
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.943007020929, Press = 0.66858806168965
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -3153.3381   -3153.3381   -3240.1569   -3240.1569    335.99772    335.99772    48773.271    48773.271    -80.51635    -80.51635 
   40000   -3156.1589   -3156.1589   -3240.2198   -3240.2198    325.32454    325.32454    48769.478    48769.478   -31.959778   -31.959778 
Loop time of 86.9257 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.994 ns/day, 24.146 hours/ns, 11.504 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    | 85.87      | 85.87      | 85.87      |   0.0 | 98.79
Neigh   | 0.51343    | 0.51343    | 0.51343    |   0.0 |  0.59
Comm    | 0.095521   | 0.095521   | 0.095521   |   0.0 |  0.11
Output  | 0.00022047 | 0.00022047 | 0.00022047 |   0.0 |  0.00
Modify  | 0.38972    | 0.38972    | 0.38972    |   0.0 |  0.45
Other   |            | 0.0568     |            |       |  0.07

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3303.00 ave        3303 max        3303 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:      115534.0 ave      115534 max      115534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115534
Ave neighs/atom = 57.767000
Neighbor list builds = 24
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
48549.2711384283

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0