# 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 313.15*${_u_temperature}
variable temp_converted equal 313.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_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   -3219.0848   -3219.0848        -3300        -3300       313.15       313.15    43206.602    43206.602    2000.3136    2000.3136 
    1000    -3190.116    -3190.116    -3270.244    -3270.244    310.10329    310.10329    47301.932    47301.932    409.20944    409.20944 
Loop time of 91.7425 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.942 ns/day, 25.484 hours/ns, 10.900 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.716     | 90.716     | 90.716     |   0.0 | 98.88
Neigh   | 0.52932    | 0.52932    | 0.52932    |   0.0 |  0.58
Comm    | 0.091093   | 0.091093   | 0.091093   |   0.0 |  0.10
Output  | 0.00020113 | 0.00020113 | 0.00020113 |   0.0 |  0.00
Modify  | 0.35134    | 0.35134    | 0.35134    |   0.0 |  0.38
Other   |            | 0.05448    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3266.00 ave        3266 max        3266 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:      119356.0 ave      119356 max      119356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119356
Ave neighs/atom = 59.678000
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    -3190.116    -3190.116    -3270.244    -3270.244    310.10329    310.10329    47301.932    47301.932    409.20944    409.20944 
    2000   -3190.6388   -3190.6388   -3272.6192   -3272.6192    317.27259    317.27259    47610.521    47610.521   -399.27459   -399.27459 
Loop time of 91.3157 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.946 ns/day, 25.365 hours/ns, 10.951 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.306     | 90.306     | 90.306     |   0.0 | 98.89
Neigh   | 0.51229    | 0.51229    | 0.51229    |   0.0 |  0.56
Comm    | 0.091812   | 0.091812   | 0.091812   |   0.0 |  0.10
Output  | 0.00022386 | 0.00022386 | 0.00022386 |   0.0 |  0.00
Modify  | 0.35013    | 0.35013    | 0.35013    |   0.0 |  0.38
Other   |            | 0.05561    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3292.00 ave        3292 max        3292 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:      118944.0 ave      118944 max      118944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118944
Ave neighs/atom = 59.472000
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 = 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   -3190.6388   -3190.6388   -3272.6192   -3272.6192    317.27259    317.27259    47610.521    47610.521   -399.27459   -399.27459 
    3000   -3189.9144   -3189.9144   -3271.6144   -3271.6144    316.18745    316.18745     47460.75     47460.75     74.04288     74.04288 
Loop time of 94.8933 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.910 ns/day, 26.359 hours/ns, 10.538 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    | 93.847     | 93.847     | 93.847     |   0.0 | 98.90
Neigh   | 0.52798    | 0.52798    | 0.52798    |   0.0 |  0.56
Comm    | 0.093537   | 0.093537   | 0.093537   |   0.0 |  0.10
Output  | 0.0002218  | 0.0002218  | 0.0002218  |   0.0 |  0.00
Modify  | 0.3682     | 0.3682     | 0.3682     |   0.0 |  0.39
Other   |            | 0.05667    |            |       |  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:      118976.0 ave      118976 max      118976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118976
Ave neighs/atom = 59.488000
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   -3189.9144   -3189.9144   -3271.6144   -3271.6144    316.18745    316.18745     47460.75     47460.75     74.04288     74.04288 
    4000   -3195.8289   -3195.8289   -3274.0336   -3274.0336    302.66021    302.66021    47295.679    47295.679    129.80117    129.80117 
Loop time of 92.6727 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.932 ns/day, 25.742 hours/ns, 10.791 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.66      | 91.66      | 91.66      |   0.0 | 98.91
Neigh   | 0.50413    | 0.50413    | 0.50413    |   0.0 |  0.54
Comm    | 0.09298    | 0.09298    | 0.09298    |   0.0 |  0.10
Output  | 0.00018992 | 0.00018992 | 0.00018992 |   0.0 |  0.00
Modify  | 0.35903    | 0.35903    | 0.35903    |   0.0 |  0.39
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:        3269.00 ave        3269 max        3269 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:      119312.0 ave      119312 max      119312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119312
Ave neighs/atom = 59.656000
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 = 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   -3195.8289   -3195.8289   -3274.0336   -3274.0336    302.66021    302.66021    47295.679    47295.679    129.80117    129.80117 
    5000   -3192.6422   -3192.6422   -3273.4465   -3273.4465    312.72103    312.72103    47313.315    47313.315     188.7191     188.7191 
Loop time of 95.164 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.908 ns/day, 26.434 hours/ns, 10.508 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    | 94.097     | 94.097     | 94.097     |   0.0 | 98.88
Neigh   | 0.54074    | 0.54074    | 0.54074    |   0.0 |  0.57
Comm    | 0.095187   | 0.095187   | 0.095187   |   0.0 |  0.10
Output  | 0.00015425 | 0.00015425 | 0.00015425 |   0.0 |  0.00
Modify  | 0.3737     | 0.3737     | 0.3737     |   0.0 |  0.39
Other   |            | 0.05741    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3330.00 ave        3330 max        3330 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:      119440.0 ave      119440 max      119440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119440
Ave neighs/atom = 59.720000
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 = 311.251874199594, Press = 55.157419941849
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 
    5000   -3192.6422   -3192.6422   -3273.4465   -3273.4465    312.72103    312.72103    47313.315    47313.315     188.7191     188.7191 
    6000   -3191.5565   -3191.5565   -3272.0891   -3272.0891    311.66953    311.66953    47326.737    47326.737    217.55046    217.55046 
Loop time of 93.3006 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.926 ns/day, 25.917 hours/ns, 10.718 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.263     | 92.263     | 92.263     |   0.0 | 98.89
Neigh   | 0.50789    | 0.50789    | 0.50789    |   0.0 |  0.54
Comm    | 0.094074   | 0.094074   | 0.094074   |   0.0 |  0.10
Output  | 0.000154   | 0.000154   | 0.000154   |   0.0 |  0.00
Modify  | 0.37885    | 0.37885    | 0.37885    |   0.0 |  0.41
Other   |            | 0.05647    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3313.00 ave        3313 max        3313 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:      119234.0 ave      119234 max      119234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119234
Ave neighs/atom = 59.617000
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 = 313.912948644454, Press = 37.0393400108451
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   -3191.5565   -3191.5565   -3272.0891   -3272.0891    311.66953    311.66953    47326.737    47326.737    217.55046    217.55046 
    7000   -3190.2809   -3190.2809   -3270.5983   -3270.5983    310.83671    310.83671    47597.879    47597.879   -199.98306   -199.98306 
Loop time of 93.3758 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.925 ns/day, 25.938 hours/ns, 10.709 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 92.328     | 92.328     | 92.328     |   0.0 | 98.88
Neigh   | 0.51602    | 0.51602    | 0.51602    |   0.0 |  0.55
Comm    | 0.093384   | 0.093384   | 0.093384   |   0.0 |  0.10
Output  | 0.00015578 | 0.00015578 | 0.00015578 |   0.0 |  0.00
Modify  | 0.38178    | 0.38178    | 0.38178    |   0.0 |  0.41
Other   |            | 0.05664    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3277.00 ave        3277 max        3277 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:      118846.0 ave      118846 max      118846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118846
Ave neighs/atom = 59.423000
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 = 313.711540481674, Press = 23.9519040019093
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   -3190.2809   -3190.2809   -3270.5983   -3270.5983    310.83671    310.83671    47597.879    47597.879   -199.98306   -199.98306 
    8000   -3193.2361   -3193.2361   -3272.7682   -3272.7682    307.79712    307.79712    47664.133    47664.133   -494.48517   -494.48517 
Loop time of 93.8908 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.920 ns/day, 26.081 hours/ns, 10.651 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.842     | 92.842     | 92.842     |   0.0 | 98.88
Neigh   | 0.51571    | 0.51571    | 0.51571    |   0.0 |  0.55
Comm    | 0.093591   | 0.093591   | 0.093591   |   0.0 |  0.10
Output  | 0.00015549 | 0.00015549 | 0.00015549 |   0.0 |  0.00
Modify  | 0.38236    | 0.38236    | 0.38236    |   0.0 |  0.41
Other   |            | 0.05653    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3251.00 ave        3251 max        3251 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:      118946.0 ave      118946 max      118946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118946
Ave neighs/atom = 59.473000
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 = 312.858243224631, Press = 17.8337228220632
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   -3193.2361   -3193.2361   -3272.7682   -3272.7682    307.79712    307.79712    47664.133    47664.133   -494.48517   -494.48517 
    9000   -3195.1543   -3195.1543   -3273.3131   -3273.3131    302.48277    302.48277    47492.994    47492.994   -195.56586   -195.56586 
Loop time of 94.1822 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.917 ns/day, 26.162 hours/ns, 10.618 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    | 93.121     | 93.121     | 93.121     |   0.0 | 98.87
Neigh   | 0.52901    | 0.52901    | 0.52901    |   0.0 |  0.56
Comm    | 0.093714   | 0.093714   | 0.093714   |   0.0 |  0.10
Output  | 0.00015332 | 0.00015332 | 0.00015332 |   0.0 |  0.00
Modify  | 0.38102    | 0.38102    | 0.38102    |   0.0 |  0.40
Other   |            | 0.0569     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3310.00 ave        3310 max        3310 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:      119092.0 ave      119092 max      119092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119092
Ave neighs/atom = 59.546000
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 = 312.567222102296, Press = 1.05646187091624
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   -3195.1543   -3195.1543   -3273.3131   -3273.3131    302.48277    302.48277    47492.994    47492.994   -195.56586   -195.56586 
   10000   -3190.8234   -3190.8234   -3273.9621   -3273.9621    321.75537    321.75537    47427.393    47427.393    57.499955    57.499955 
Loop time of 94.0703 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.918 ns/day, 26.131 hours/ns, 10.630 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.999     | 92.999     | 92.999     |   0.0 | 98.86
Neigh   | 0.53474    | 0.53474    | 0.53474    |   0.0 |  0.57
Comm    | 0.094677   | 0.094677   | 0.094677   |   0.0 |  0.10
Output  | 0.00015572 | 0.00015572 | 0.00015572 |   0.0 |  0.00
Modify  | 0.3848     | 0.3848     | 0.3848     |   0.0 |  0.41
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:        3345.00 ave        3345 max        3345 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:      119416.0 ave      119416 max      119416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119416
Ave neighs/atom = 59.708000
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 = 312.747848054188, Press = 5.09751309483904
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 
   10000   -3190.8234   -3190.8234   -3273.9621   -3273.9621    321.75537    321.75537    47427.393    47427.393    57.499955    57.499955 
   11000   -3191.4728   -3191.4728   -3272.1778   -3272.1778    312.33677    312.33677    47419.248    47419.248    9.2925608    9.2925608 
Loop time of 96.1893 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.719 hours/ns, 10.396 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    | 95.105     | 95.105     | 95.105     |   0.0 | 98.87
Neigh   | 0.53644    | 0.53644    | 0.53644    |   0.0 |  0.56
Comm    | 0.096587   | 0.096587   | 0.096587   |   0.0 |  0.10
Output  | 0.00014782 | 0.00014782 | 0.00014782 |   0.0 |  0.00
Modify  | 0.39279    | 0.39279    | 0.39279    |   0.0 |  0.41
Other   |            | 0.05835    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3296.00 ave        3296 max        3296 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:      119162.0 ave      119162 max      119162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119162
Ave neighs/atom = 59.581000
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 = 312.545500577286, Press = 4.83265176147092
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   -3191.4728   -3191.4728   -3272.1778   -3272.1778    312.33677    312.33677    47419.248    47419.248    9.2925608    9.2925608 
   12000   -3193.1502   -3193.1502   -3272.8034   -3272.8034    308.26626    308.26626    47418.171    47418.171    135.34205    135.34205 
Loop time of 96.4615 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.795 hours/ns, 10.367 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    | 95.371     | 95.371     | 95.371     |   0.0 | 98.87
Neigh   | 0.54237    | 0.54237    | 0.54237    |   0.0 |  0.56
Comm    | 0.095935   | 0.095935   | 0.095935   |   0.0 |  0.10
Output  | 0.00015597 | 0.00015597 | 0.00015597 |   0.0 |  0.00
Modify  | 0.39416    | 0.39416    | 0.39416    |   0.0 |  0.41
Other   |            | 0.05799    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3353.00 ave        3353 max        3353 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:      119166.0 ave      119166 max      119166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119166
Ave neighs/atom = 59.583000
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 = 312.742719120782, Press = 4.9314667501151
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 
   12000   -3193.1502   -3193.1502   -3272.8034   -3272.8034    308.26626    308.26626    47418.171    47418.171    135.34205    135.34205 
   13000    -3192.103    -3192.103   -3272.9611   -3272.9611    312.92925    312.92925      47383.5      47383.5     165.7486     165.7486 
Loop time of 95.3435 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.906 ns/day, 26.484 hours/ns, 10.488 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    | 94.286     | 94.286     | 94.286     |   0.0 | 98.89
Neigh   | 0.51532    | 0.51532    | 0.51532    |   0.0 |  0.54
Comm    | 0.094344   | 0.094344   | 0.094344   |   0.0 |  0.10
Output  | 0.00019508 | 0.00019508 | 0.00019508 |   0.0 |  0.00
Modify  | 0.39042    | 0.39042    | 0.39042    |   0.0 |  0.41
Other   |            | 0.05695    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3292.00 ave        3292 max        3292 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:      119122.0 ave      119122 max      119122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119122
Ave neighs/atom = 59.561000
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 = 312.729949836294, Press = 5.92430576203409
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    -3192.103    -3192.103   -3272.9611   -3272.9611    312.92925    312.92925      47383.5      47383.5     165.7486     165.7486 
   14000   -3192.0111   -3192.0111   -3272.7032   -3272.7032    312.28675    312.28675    47751.726    47751.726   -497.52115   -497.52115 
Loop time of 96.8131 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.892 ns/day, 26.893 hours/ns, 10.329 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    | 95.721     | 95.721     | 95.721     |   0.0 | 98.87
Neigh   | 0.54338    | 0.54338    | 0.54338    |   0.0 |  0.56
Comm    | 0.095688   | 0.095688   | 0.095688   |   0.0 |  0.10
Output  | 0.00025402 | 0.00025402 | 0.00025402 |   0.0 |  0.00
Modify  | 0.39546    | 0.39546    | 0.39546    |   0.0 |  0.41
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:        3301.00 ave        3301 max        3301 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:      118744.0 ave      118744 max      118744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118744
Ave neighs/atom = 59.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 = 312.776891600134, Press = 9.57993773162759
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   -3192.0111   -3192.0111   -3272.7032   -3272.7032    312.28675    312.28675    47751.726    47751.726   -497.52115   -497.52115 
   15000   -3192.7914   -3192.7914    -3272.636    -3272.636    309.00666    309.00666    47540.614    47540.614   -296.68939   -296.68939 
Loop time of 96.5506 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.820 hours/ns, 10.357 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    | 95.455     | 95.455     | 95.455     |   0.0 | 98.87
Neigh   | 0.5439     | 0.5439     | 0.5439     |   0.0 |  0.56
Comm    | 0.096789   | 0.096789   | 0.096789   |   0.0 |  0.10
Output  | 0.00015564 | 0.00015564 | 0.00015564 |   0.0 |  0.00
Modify  | 0.397      | 0.397      | 0.397      |   0.0 |  0.41
Other   |            | 0.05772    |            |       |  0.06

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:      119140.0 ave      119140 max      119140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119140
Ave neighs/atom = 59.570000
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 = 312.816769237837, Press = 2.48355467661123
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 
   15000   -3192.7914   -3192.7914    -3272.636    -3272.636    309.00666    309.00666    47540.614    47540.614   -296.68939   -296.68939 
   16000   -3191.1028   -3191.1028   -3274.5058   -3274.5058    322.77813    322.77813    47460.649    47460.649   -31.635128   -31.635128 
Loop time of 96.1982 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.722 hours/ns, 10.395 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    | 95.135     | 95.135     | 95.135     |   0.0 | 98.89
Neigh   | 0.51519    | 0.51519    | 0.51519    |   0.0 |  0.54
Comm    | 0.095611   | 0.095611   | 0.095611   |   0.0 |  0.10
Output  | 0.00015067 | 0.00015067 | 0.00015067 |   0.0 |  0.00
Modify  | 0.39467    | 0.39467    | 0.39467    |   0.0 |  0.41
Other   |            | 0.05747    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3328.00 ave        3328 max        3328 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:      119250.0 ave      119250 max      119250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119250
Ave neighs/atom = 59.625000
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 = 312.526279463833, Press = 1.67945535903077
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   -3191.1028   -3191.1028   -3274.5058   -3274.5058    322.77813    322.77813    47460.649    47460.649   -31.635128   -31.635128 
   17000   -3186.5237   -3186.5237     -3270.18     -3270.18    323.75847    323.75847    47473.091    47473.091    161.26761    161.26761 
Loop time of 94.8932 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.910 ns/day, 26.359 hours/ns, 10.538 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    | 93.812     | 93.812     | 93.812     |   0.0 | 98.86
Neigh   | 0.54121    | 0.54121    | 0.54121    |   0.0 |  0.57
Comm    | 0.095516   | 0.095516   | 0.095516   |   0.0 |  0.10
Output  | 0.00020144 | 0.00020144 | 0.00020144 |   0.0 |  0.00
Modify  | 0.38738    | 0.38738    | 0.38738    |   0.0 |  0.41
Other   |            | 0.05682    |            |       |  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:      119108.0 ave      119108 max      119108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119108
Ave neighs/atom = 59.554000
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 = 312.564362604291, Press = 0.573786180486642
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   -3186.5237   -3186.5237     -3270.18     -3270.18    323.75847    323.75847    47473.091    47473.091    161.26761    161.26761 
   18000   -3192.3121   -3192.3121   -3273.6894   -3273.6894    314.93836    314.93836    47279.004    47279.004    481.39132    481.39132 
Loop time of 96.2351 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.732 hours/ns, 10.391 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    | 95.172     | 95.172     | 95.172     |   0.0 | 98.90
Neigh   | 0.5154     | 0.5154     | 0.5154     |   0.0 |  0.54
Comm    | 0.095375   | 0.095375   | 0.095375   |   0.0 |  0.10
Output  | 0.00019438 | 0.00019438 | 0.00019438 |   0.0 |  0.00
Modify  | 0.39451    | 0.39451    | 0.39451    |   0.0 |  0.41
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:        3297.00 ave        3297 max        3297 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:      119304.0 ave      119304 max      119304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119304
Ave neighs/atom = 59.652000
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 = 312.711582511406, Press = 0.557736331359371
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   -3192.3121   -3192.3121   -3273.6894   -3273.6894    314.93836    314.93836    47279.004    47279.004    481.39132    481.39132 
   19000   -3196.1395   -3196.1395   -3276.0754   -3276.0754    309.35997    309.35997    47265.659    47265.659    480.94571    480.94571 
Loop time of 95.763 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.601 hours/ns, 10.442 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    | 94.688     | 94.688     | 94.688     |   0.0 | 98.88
Neigh   | 0.53083    | 0.53083    | 0.53083    |   0.0 |  0.55
Comm    | 0.095826   | 0.095826   | 0.095826   |   0.0 |  0.10
Output  | 0.00015416 | 0.00015416 | 0.00015416 |   0.0 |  0.00
Modify  | 0.39146    | 0.39146    | 0.39146    |   0.0 |  0.41
Other   |            | 0.0568     |            |       |  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:      119582.0 ave      119582 max      119582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119582
Ave neighs/atom = 59.791000
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 = 312.798682852285, Press = 2.27893380978665
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   -3196.1395   -3196.1395   -3276.0754   -3276.0754    309.35997    309.35997    47265.659    47265.659    480.94571    480.94571 
   20000   -3194.1449   -3194.1449   -3276.4029   -3276.4029    318.34701    318.34701    47491.327    47491.327     22.44936     22.44936 
Loop time of 96.1529 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.709 hours/ns, 10.400 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    | 95.104     | 95.104     | 95.104     |   0.0 | 98.91
Neigh   | 0.51063    | 0.51063    | 0.51063    |   0.0 |  0.53
Comm    | 0.09443    | 0.09443    | 0.09443    |   0.0 |  0.10
Output  | 0.00015477 | 0.00015477 | 0.00015477 |   0.0 |  0.00
Modify  | 0.38671    | 0.38671    | 0.38671    |   0.0 |  0.40
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:        3329.00 ave        3329 max        3329 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:      119134.0 ave      119134 max      119134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119134
Ave neighs/atom = 59.567000
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 = 312.907139190745, Press = 1.77053469664079
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   -3194.1449   -3194.1449   -3276.4029   -3276.4029    318.34701    318.34701    47491.327    47491.327     22.44936     22.44936 
   21000     -3195.97     -3195.97   -3277.4506   -3277.4506    315.33861    315.33861    47420.548    47420.548    68.949281    68.949281 
Loop time of 98.4367 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.344 hours/ns, 10.159 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    | 97.367     | 97.367     | 97.367     |   0.0 | 98.91
Neigh   | 0.51604    | 0.51604    | 0.51604    |   0.0 |  0.52
Comm    | 0.096235   | 0.096235   | 0.096235   |   0.0 |  0.10
Output  | 0.00019092 | 0.00019092 | 0.00019092 |   0.0 |  0.00
Modify  | 0.39915    | 0.39915    | 0.39915    |   0.0 |  0.41
Other   |            | 0.05781    |            |       |  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:      119190.0 ave      119190 max      119190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119190
Ave neighs/atom = 59.595000
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 = 312.983112347368, Press = 3.30653840982065
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 
   21000     -3195.97     -3195.97   -3277.4506   -3277.4506    315.33861    315.33861    47420.548    47420.548    68.949281    68.949281 
   22000   -3197.8144   -3197.8144   -3275.9364   -3275.9364    302.34025    302.34025     47454.15     47454.15    12.210266    12.210266 
Loop time of 96.1223 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.701 hours/ns, 10.403 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    | 95.07      | 95.07      | 95.07      |   0.0 | 98.91
Neigh   | 0.51005    | 0.51005    | 0.51005    |   0.0 |  0.53
Comm    | 0.094858   | 0.094858   | 0.094858   |   0.0 |  0.10
Output  | 0.00015672 | 0.00015672 | 0.00015672 |   0.0 |  0.00
Modify  | 0.39021    | 0.39021    | 0.39021    |   0.0 |  0.41
Other   |            | 0.05708    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3344.00 ave        3344 max        3344 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:      119128.0 ave      119128 max      119128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119128
Ave neighs/atom = 59.564000
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 = 313.003969157961, Press = 2.0094737178441
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 
   22000   -3197.8144   -3197.8144   -3275.9364   -3275.9364    302.34025    302.34025     47454.15     47454.15    12.210266    12.210266 
   23000    -3195.297    -3195.297   -3276.9221   -3276.9221    315.89787    315.89787    47636.831    47636.831   -366.58456   -366.58456 
Loop time of 96.2891 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.747 hours/ns, 10.385 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    | 95.244     | 95.244     | 95.244     |   0.0 | 98.91
Neigh   | 0.50542    | 0.50542    | 0.50542    |   0.0 |  0.52
Comm    | 0.094392   | 0.094392   | 0.094392   |   0.0 |  0.10
Output  | 0.00015468 | 0.00015468 | 0.00015468 |   0.0 |  0.00
Modify  | 0.38869    | 0.38869    | 0.38869    |   0.0 |  0.40
Other   |            | 0.05693    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3296.00 ave        3296 max        3296 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:      118914.0 ave      118914 max      118914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118914
Ave neighs/atom = 59.457000
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 = 312.964611116421, Press = 1.49033725159045
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 
   23000    -3195.297    -3195.297   -3276.9221   -3276.9221    315.89787    315.89787    47636.831    47636.831   -366.58456   -366.58456 
   24000   -3197.6488   -3197.6488   -3278.6394   -3278.6394     313.4419     313.4419    47613.618    47613.618   -285.49143   -285.49143 
Loop time of 95.4916 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.905 ns/day, 26.525 hours/ns, 10.472 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    | 94.431     | 94.431     | 94.431     |   0.0 | 98.89
Neigh   | 0.5263     | 0.5263     | 0.5263     |   0.0 |  0.55
Comm    | 0.093893   | 0.093893   | 0.093893   |   0.0 |  0.10
Output  | 0.00018495 | 0.00018495 | 0.00018495 |   0.0 |  0.00
Modify  | 0.38348    | 0.38348    | 0.38348    |   0.0 |  0.40
Other   |            | 0.05677    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3328.00 ave        3328 max        3328 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:      118690.0 ave      118690 max      118690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118690
Ave neighs/atom = 59.345000
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 = 312.84980105141, Press = 1.03652772538247
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   -3197.6488   -3197.6488   -3278.6394   -3278.6394     313.4419     313.4419    47613.618    47613.618   -285.49143   -285.49143 
   25000   -3193.2955   -3193.2955   -3276.6323   -3276.6323    322.52193    322.52193    47691.451    47691.451    -469.7682    -469.7682 
Loop time of 95.6615 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.573 hours/ns, 10.454 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    | 94.591     | 94.591     | 94.591     |   0.0 | 98.88
Neigh   | 0.53333    | 0.53333    | 0.53333    |   0.0 |  0.56
Comm    | 0.095269   | 0.095269   | 0.095269   |   0.0 |  0.10
Output  | 0.00015531 | 0.00015531 | 0.00015531 |   0.0 |  0.00
Modify  | 0.38492    | 0.38492    | 0.38492    |   0.0 |  0.40
Other   |            | 0.05665    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3347.00 ave        3347 max        3347 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:      118700.0 ave      118700 max      118700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118700
Ave neighs/atom = 59.350000
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 = 312.853848456457, Press = 0.237472681380342
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 
   25000   -3193.2955   -3193.2955   -3276.6323   -3276.6323    322.52193    322.52193    47691.451    47691.451    -469.7682    -469.7682 
   26000    -3198.469    -3198.469   -3278.9861   -3278.9861    311.60928    311.60928    47456.088    47456.088   -23.212433   -23.212433 
Loop time of 96.9933 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.891 ns/day, 26.943 hours/ns, 10.310 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    | 95.917     | 95.917     | 95.917     |   0.0 | 98.89
Neigh   | 0.53041    | 0.53041    | 0.53041    |   0.0 |  0.55
Comm    | 0.095538   | 0.095538   | 0.095538   |   0.0 |  0.10
Output  | 0.0002688  | 0.0002688  | 0.0002688  |   0.0 |  0.00
Modify  | 0.39301    | 0.39301    | 0.39301    |   0.0 |  0.41
Other   |            | 0.05657    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3318.00 ave        3318 max        3318 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:      118962.0 ave      118962 max      118962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118962
Ave neighs/atom = 59.481000
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 = 312.786186935917, Press = -1.34380924149158
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    -3198.469    -3198.469   -3278.9861   -3278.9861    311.60928    311.60928    47456.088    47456.088   -23.212433   -23.212433 
   27000   -3191.8435   -3191.8435   -3274.6685   -3274.6685    320.54141    320.54141    47313.452    47313.452    500.32794    500.32794 
Loop time of 94.5659 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.914 ns/day, 26.268 hours/ns, 10.575 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    | 93.504     | 93.504     | 93.504     |   0.0 | 98.88
Neigh   | 0.52989    | 0.52989    | 0.52989    |   0.0 |  0.56
Comm    | 0.094414   | 0.094414   | 0.094414   |   0.0 |  0.10
Output  | 0.00015653 | 0.00015653 | 0.00015653 |   0.0 |  0.00
Modify  | 0.38157    | 0.38157    | 0.38157    |   0.0 |  0.40
Other   |            | 0.05629    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3291.00 ave        3291 max        3291 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:      119190.0 ave      119190 max      119190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119190
Ave neighs/atom = 59.595000
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 = 312.832374557881, Press = 0.968117309939008
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   -3191.8435   -3191.8435   -3274.6685   -3274.6685    320.54141    320.54141    47313.452    47313.452    500.32794    500.32794 
   28000   -3194.9634   -3194.9634   -3277.1826   -3277.1826    318.19662    318.19662    47369.712    47369.712    32.380294    32.380294 
Loop time of 93.9848 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.919 ns/day, 26.107 hours/ns, 10.640 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.937     | 92.937     | 92.937     |   0.0 | 98.88
Neigh   | 0.5212     | 0.5212     | 0.5212     |   0.0 |  0.55
Comm    | 0.093538   | 0.093538   | 0.093538   |   0.0 |  0.10
Output  | 0.00019641 | 0.00019641 | 0.00019641 |   0.0 |  0.00
Modify  | 0.37739    | 0.37739    | 0.37739    |   0.0 |  0.40
Other   |            | 0.05572    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3358.00 ave        3358 max        3358 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:      119462.0 ave      119462 max      119462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119462
Ave neighs/atom = 59.731000
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 = 312.850662824529, Press = 1.70989436067816
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 
   28000   -3194.9634   -3194.9634   -3277.1826   -3277.1826    318.19662    318.19662    47369.712    47369.712    32.380294    32.380294 
   29000    -3196.832    -3196.832   -3276.4631   -3276.4631    308.18057    308.18057    47330.354    47330.354    184.73761    184.73761 
Loop time of 94.9499 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.910 ns/day, 26.375 hours/ns, 10.532 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    | 93.909     | 93.909     | 93.909     |   0.0 | 98.90
Neigh   | 0.50589    | 0.50589    | 0.50589    |   0.0 |  0.53
Comm    | 0.093958   | 0.093958   | 0.093958   |   0.0 |  0.10
Output  | 0.00015429 | 0.00015429 | 0.00015429 |   0.0 |  0.00
Modify  | 0.38383    | 0.38383    | 0.38383    |   0.0 |  0.40
Other   |            | 0.05661    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3363.00 ave        3363 max        3363 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:      119034.0 ave      119034 max      119034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119034
Ave neighs/atom = 59.517000
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 = 312.869627176953, Press = 1.2488527728473
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 
   29000    -3196.832    -3196.832   -3276.4631   -3276.4631    308.18057    308.18057    47330.354    47330.354    184.73761    184.73761 
   30000   -3193.8629   -3193.8629   -3275.5104   -3275.5104    315.98442    315.98442    47520.132    47520.132   -48.819692   -48.819692 
Loop time of 95.8493 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.625 hours/ns, 10.433 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    | 94.802     | 94.802     | 94.802     |   0.0 | 98.91
Neigh   | 0.50868    | 0.50868    | 0.50868    |   0.0 |  0.53
Comm    | 0.095079   | 0.095079   | 0.095079   |   0.0 |  0.10
Output  | 0.00019658 | 0.00019658 | 0.00019658 |   0.0 |  0.00
Modify  | 0.38665    | 0.38665    | 0.38665    |   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:        3335.00 ave        3335 max        3335 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:      119112.0 ave      119112 max      119112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119112
Ave neighs/atom = 59.556000
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 = 312.924649996238, Press = 1.65589012502552
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 
   30000   -3193.8629   -3193.8629   -3275.5104   -3275.5104    315.98442    315.98442    47520.132    47520.132   -48.819692   -48.819692 
   31000   -3195.6717   -3195.6717   -3275.2831   -3275.2831    308.10433    308.10433    47584.989    47584.989   -304.46252   -304.46252 
Loop time of 96.8322 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.892 ns/day, 26.898 hours/ns, 10.327 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    | 95.784     | 95.784     | 95.784     |   0.0 | 98.92
Neigh   | 0.50434    | 0.50434    | 0.50434    |   0.0 |  0.52
Comm    | 0.096048   | 0.096048   | 0.096048   |   0.0 |  0.10
Output  | 0.00015129 | 0.00015129 | 0.00015129 |   0.0 |  0.00
Modify  | 0.39086    | 0.39086    | 0.39086    |   0.0 |  0.40
Other   |            | 0.0567     |            |       |  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:      119050.0 ave      119050 max      119050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119050
Ave neighs/atom = 59.525000
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 = 313.0492249534, Press = 2.36328683735543
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   -3195.6717   -3195.6717   -3275.2831   -3275.2831    308.10433    308.10433    47584.989    47584.989   -304.46252   -304.46252 
   32000     -3197.43     -3197.43   -3277.6862   -3277.6862    310.59995    310.59995    47674.719    47674.719   -540.50326   -540.50326 
Loop time of 96.0644 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.685 hours/ns, 10.410 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.995     | 94.995     | 94.995     |   0.0 | 98.89
Neigh   | 0.53051    | 0.53051    | 0.53051    |   0.0 |  0.55
Comm    | 0.095368   | 0.095368   | 0.095368   |   0.0 |  0.10
Output  | 0.00018314 | 0.00018314 | 0.00018314 |   0.0 |  0.00
Modify  | 0.3869     | 0.3869     | 0.3869     |   0.0 |  0.40
Other   |            | 0.05669    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3323.00 ave        3323 max        3323 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:      118808.0 ave      118808 max      118808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118808
Ave neighs/atom = 59.404000
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 = 312.931031808477, Press = 1.51335294418544
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 
   32000     -3197.43     -3197.43   -3277.6862   -3277.6862    310.59995    310.59995    47674.719    47674.719   -540.50326   -540.50326 
   33000   -3199.8976   -3199.8976   -3277.6701   -3277.6701    300.98763    300.98763    47586.651    47586.651   -427.69497   -427.69497 
Loop time of 93.9009 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.920 ns/day, 26.084 hours/ns, 10.650 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.874     | 92.874     | 92.874     |   0.0 | 98.91
Neigh   | 0.50238    | 0.50238    | 0.50238    |   0.0 |  0.54
Comm    | 0.092531   | 0.092531   | 0.092531   |   0.0 |  0.10
Output  | 0.00019228 | 0.00019228 | 0.00019228 |   0.0 |  0.00
Modify  | 0.37581    | 0.37581    | 0.37581    |   0.0 |  0.40
Other   |            | 0.05589    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3308.00 ave        3308 max        3308 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:      118878.0 ave      118878 max      118878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118878
Ave neighs/atom = 59.439000
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 = 312.934142377101, Press = 0.460518157768645
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 
   33000   -3199.8976   -3199.8976   -3277.6701   -3277.6701    300.98763    300.98763    47586.651    47586.651   -427.69497   -427.69497 
   34000   -3195.8506   -3195.8506   -3276.6731   -3276.6731    312.79132    312.79132    47380.387    47380.387    230.98225    230.98225 
Loop time of 96.2898 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.747 hours/ns, 10.385 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    | 95.219     | 95.219     | 95.219     |   0.0 | 98.89
Neigh   | 0.53054    | 0.53054    | 0.53054    |   0.0 |  0.55
Comm    | 0.09515    | 0.09515    | 0.09515    |   0.0 |  0.10
Output  | 0.00015548 | 0.00015548 | 0.00015548 |   0.0 |  0.00
Modify  | 0.38798    | 0.38798    | 0.38798    |   0.0 |  0.40
Other   |            | 0.05681    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3342.00 ave        3342 max        3342 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:      119216.0 ave      119216 max      119216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119216
Ave neighs/atom = 59.608000
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 = 312.893728582565, Press = -0.2640690541466
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 
   34000   -3195.8506   -3195.8506   -3276.6731   -3276.6731    312.79132    312.79132    47380.387    47380.387    230.98225    230.98225 
   35000   -3194.5697   -3194.5697   -3277.0312   -3277.0312    319.13455    319.13455    47339.961    47339.961    321.61642    321.61642 
Loop time of 92.586 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.933 ns/day, 25.718 hours/ns, 10.801 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.554     | 91.554     | 91.554     |   0.0 | 98.89
Neigh   | 0.51696    | 0.51696    | 0.51696    |   0.0 |  0.56
Comm    | 0.091877   | 0.091877   | 0.091877   |   0.0 |  0.10
Output  | 0.000157   | 0.000157   | 0.000157   |   0.0 |  0.00
Modify  | 0.36736    | 0.36736    | 0.36736    |   0.0 |  0.40
Other   |            | 0.05564    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3357.00 ave        3357 max        3357 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:      119310.0 ave      119310 max      119310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119310
Ave neighs/atom = 59.655000
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 = 312.928170614772, Press = 0.834382498026821
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 
   35000   -3194.5697   -3194.5697   -3277.0312   -3277.0312    319.13455    319.13455    47339.961    47339.961    321.61642    321.61642 
   36000   -3197.5369   -3197.5369   -3278.2176   -3278.2176    312.24277    312.24277    47345.615    47345.615     196.7193     196.7193 
Loop time of 95.3719 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.906 ns/day, 26.492 hours/ns, 10.485 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    | 94.334     | 94.334     | 94.334     |   0.0 | 98.91
Neigh   | 0.50346    | 0.50346    | 0.50346    |   0.0 |  0.53
Comm    | 0.093927   | 0.093927   | 0.093927   |   0.0 |  0.10
Output  | 0.0001567  | 0.0001567  | 0.0001567  |   0.0 |  0.00
Modify  | 0.38284    | 0.38284    | 0.38284    |   0.0 |  0.40
Other   |            | 0.05735    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3337.00 ave        3337 max        3337 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:      119634.0 ave      119634 max      119634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119634
Ave neighs/atom = 59.817000
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 = 312.955438043555, Press = 1.31332677379531
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 
   36000   -3197.5369   -3197.5369   -3278.2176   -3278.2176    312.24277    312.24277    47345.615    47345.615     196.7193     196.7193 
   37000   -3198.1914   -3198.1914     -3278.84     -3278.84    312.11852    312.11852    47439.537    47439.537    30.631787    30.631787 
Loop time of 94.0335 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.919 ns/day, 26.120 hours/ns, 10.635 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.983     | 92.983     | 92.983     |   0.0 | 98.88
Neigh   | 0.52461    | 0.52461    | 0.52461    |   0.0 |  0.56
Comm    | 0.092635   | 0.092635   | 0.092635   |   0.0 |  0.10
Output  | 0.00015422 | 0.00015422 | 0.00015422 |   0.0 |  0.00
Modify  | 0.3766     | 0.3766     | 0.3766     |   0.0 |  0.40
Other   |            | 0.05602    |            |       |  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:      119110.0 ave      119110 max      119110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119110
Ave neighs/atom = 59.555000
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 = 312.850348316862, Press = 1.23615488224629
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 
   37000   -3198.1914   -3198.1914     -3278.84     -3278.84    312.11852    312.11852    47439.537    47439.537    30.631787    30.631787 
   38000   -3198.4699   -3198.4699   -3278.0835   -3278.0835     308.1128     308.1128     47451.54     47451.54   -32.822187   -32.822187 
Loop time of 93.9071 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.920 ns/day, 26.085 hours/ns, 10.649 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.879     | 92.879     | 92.879     |   0.0 | 98.90
Neigh   | 0.50221    | 0.50221    | 0.50221    |   0.0 |  0.53
Comm    | 0.094014   | 0.094014   | 0.094014   |   0.0 |  0.10
Output  | 0.00015487 | 0.00015487 | 0.00015487 |   0.0 |  0.00
Modify  | 0.37554    | 0.37554    | 0.37554    |   0.0 |  0.40
Other   |            | 0.05647    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3367.00 ave        3367 max        3367 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:      119158.0 ave      119158 max      119158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119158
Ave neighs/atom = 59.579000
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 = 312.829177623638, Press = 1.00077704877058
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 
   38000   -3198.4699   -3198.4699   -3278.0835   -3278.0835     308.1128     308.1128     47451.54     47451.54   -32.822187   -32.822187 
   39000   -3197.6139   -3197.6139   -3277.8926   -3277.8926      310.687      310.687    47377.967    47377.967    338.09495    338.09495 
Loop time of 94.8836 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.911 ns/day, 26.357 hours/ns, 10.539 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    | 93.858     | 93.858     | 93.858     |   0.0 | 98.92
Neigh   | 0.49592    | 0.49592    | 0.49592    |   0.0 |  0.52
Comm    | 0.093433   | 0.093433   | 0.093433   |   0.0 |  0.10
Output  | 0.00019481 | 0.00019481 | 0.00019481 |   0.0 |  0.00
Modify  | 0.37972    | 0.37972    | 0.37972    |   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:        3353.00 ave        3353 max        3353 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:      119144.0 ave      119144 max      119144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119144
Ave neighs/atom = 59.572000
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 = 312.855593036775, Press = 2.04834460065363
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 
   39000   -3197.6139   -3197.6139   -3277.8926   -3277.8926      310.687      310.687    47377.967    47377.967    338.09495    338.09495 
   40000   -3195.8314   -3195.8314   -3277.6645   -3277.6645    316.70246    316.70246    47655.634    47655.634   -346.19371   -346.19371 
Loop time of 95.7642 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.601 hours/ns, 10.442 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    | 94.701     | 94.701     | 94.701     |   0.0 | 98.89
Neigh   | 0.52661    | 0.52661    | 0.52661    |   0.0 |  0.55
Comm    | 0.094974   | 0.094974   | 0.094974   |   0.0 |  0.10
Output  | 0.00015425 | 0.00015425 | 0.00015425 |   0.0 |  0.00
Modify  | 0.38523    | 0.38523    | 0.38523    |   0.0 |  0.40
Other   |            | 0.05657    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3350.00 ave        3350 max        3350 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:      118726.0 ave      118726 max      118726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118726
Ave neighs/atom = 59.363000
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 = 312.824606395502, Press = 2.06402188651843
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 
   40000   -3195.8314   -3195.8314   -3277.6645   -3277.6645    316.70246    316.70246    47655.634    47655.634   -346.19371   -346.19371 
   41000   -3192.2788   -3192.2788   -3274.1966   -3274.1966    317.03027    317.03027    47700.289    47700.289   -471.05322   -471.05322 
Loop time of 96.23 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.731 hours/ns, 10.392 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    | 95.157     | 95.157     | 95.157     |   0.0 | 98.88
Neigh   | 0.53277    | 0.53277    | 0.53277    |   0.0 |  0.55
Comm    | 0.095807   | 0.095807   | 0.095807   |   0.0 |  0.10
Output  | 0.00015405 | 0.00015405 | 0.00015405 |   0.0 |  0.00
Modify  | 0.38786    | 0.38786    | 0.38786    |   0.0 |  0.40
Other   |            | 0.05669    |            |       |  0.06

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:      118648.0 ave      118648 max      118648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118648
Ave neighs/atom = 59.324000
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 = 312.840294594232, Press = 0.721105432403198
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 
   41000   -3192.2788   -3192.2788   -3274.1966   -3274.1966    317.03027    317.03027    47700.289    47700.289   -471.05322   -471.05322 
   42000   -3197.4976   -3197.4976   -3277.5648   -3277.5648    309.86861    309.86861    47516.122    47516.122   -41.042174   -41.042174 
Loop time of 94.1236 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.918 ns/day, 26.145 hours/ns, 10.624 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    | 93.067     | 93.067     | 93.067     |   0.0 | 98.88
Neigh   | 0.52518    | 0.52518    | 0.52518    |   0.0 |  0.56
Comm    | 0.094426   | 0.094426   | 0.094426   |   0.0 |  0.10
Output  | 0.00015431 | 0.00015431 | 0.00015431 |   0.0 |  0.00
Modify  | 0.38058    | 0.38058    | 0.38058    |   0.0 |  0.40
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:        3349.00 ave        3349 max        3349 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:      119002.0 ave      119002 max      119002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119002
Ave neighs/atom = 59.501000
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 = 312.909837184542, Press = 0.898754103979169
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 
   42000   -3197.4976   -3197.4976   -3277.5648   -3277.5648    309.86861    309.86861    47516.122    47516.122   -41.042174   -41.042174 
   43000   -3197.7139   -3197.7139   -3277.2264   -3277.2264    307.72184    307.72184    47567.185    47567.185   -57.443782   -57.443782 
Loop time of 96.9247 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.891 ns/day, 26.924 hours/ns, 10.317 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    | 95.845     | 95.845     | 95.845     |   0.0 | 98.89
Neigh   | 0.53301    | 0.53301    | 0.53301    |   0.0 |  0.55
Comm    | 0.096067   | 0.096067   | 0.096067   |   0.0 |  0.10
Output  | 0.00015517 | 0.00015517 | 0.00015517 |   0.0 |  0.00
Modify  | 0.39292    | 0.39292    | 0.39292    |   0.0 |  0.41
Other   |            | 0.05741    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3327.00 ave        3327 max        3327 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:      118794.0 ave      118794 max      118794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118794
Ave neighs/atom = 59.397000
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 = 312.915680195155, Press = 0.329685031434937
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 
   43000   -3197.7139   -3197.7139   -3277.2264   -3277.2264    307.72184    307.72184    47567.185    47567.185   -57.443782   -57.443782 
   44000   -3190.3539   -3190.3539   -3273.0077   -3273.0077    319.87902    319.87902    47587.238    47587.238   -253.99554   -253.99554 
Loop time of 97.0323 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.890 ns/day, 26.953 hours/ns, 10.306 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    | 95.955     | 95.955     | 95.955     |   0.0 | 98.89
Neigh   | 0.53226    | 0.53226    | 0.53226    |   0.0 |  0.55
Comm    | 0.095315   | 0.095315   | 0.095315   |   0.0 |  0.10
Output  | 0.00021818 | 0.00021818 | 0.00021818 |   0.0 |  0.00
Modify  | 0.39242    | 0.39242    | 0.39242    |   0.0 |  0.40
Other   |            | 0.05682    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3327.00 ave        3327 max        3327 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:      118804.0 ave      118804 max      118804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118804
Ave neighs/atom = 59.402000
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 = 312.937626521944, Press = 0.310370510481199
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 
   44000   -3190.3539   -3190.3539   -3273.0077   -3273.0077    319.87902    319.87902    47587.238    47587.238   -253.99554   -253.99554 
   45000   -3197.1758   -3197.1758   -3280.0919   -3280.0919    320.89405    320.89405    47542.961    47542.961   -206.24534   -206.24534 
Loop time of 94.2577 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.917 ns/day, 26.183 hours/ns, 10.609 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    | 93.228     | 93.228     | 93.228     |   0.0 | 98.91
Neigh   | 0.50053    | 0.50053    | 0.50053    |   0.0 |  0.53
Comm    | 0.093149   | 0.093149   | 0.093149   |   0.0 |  0.10
Output  | 0.00015696 | 0.00015696 | 0.00015696 |   0.0 |  0.00
Modify  | 0.37965    | 0.37965    | 0.37965    |   0.0 |  0.40
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:        3312.00 ave        3312 max        3312 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:      118650.0 ave      118650 max      118650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118650
Ave neighs/atom = 59.325000
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 = 312.999300158594, Press = -0.245907843606493
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 
   45000   -3197.1758   -3197.1758   -3280.0919   -3280.0919    320.89405    320.89405    47542.961    47542.961   -206.24534   -206.24534 
   46000   -3197.0356   -3197.0356   -3277.9438   -3277.9438    313.12297    313.12297    47333.664    47333.664    343.13857    343.13857 
Loop time of 94.6793 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.913 ns/day, 26.300 hours/ns, 10.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    | 93.648     | 93.648     | 93.648     |   0.0 | 98.91
Neigh   | 0.50156    | 0.50156    | 0.50156    |   0.0 |  0.53
Comm    | 0.094152   | 0.094152   | 0.094152   |   0.0 |  0.10
Output  | 0.00015437 | 0.00015437 | 0.00015437 |   0.0 |  0.00
Modify  | 0.37925    | 0.37925    | 0.37925    |   0.0 |  0.40
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:        3314.00 ave        3314 max        3314 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:      119108.0 ave      119108 max      119108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119108
Ave neighs/atom = 59.554000
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"
jump SELF break

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0