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

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

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

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

kim_interactions Al

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

kim interactions Al
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_SongMendelev_2021_AlSm__MO_722733117926_000
pair_coeff * * Al
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 26.981538

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66161.1936860816 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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_722733117926_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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.386 | 7.386 | 7.386 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -13095.821   -13095.821   -13247.353   -13247.353       293.15       293.15    66161.194    66161.194    2446.3663    2446.3663 
    1000   -12931.684   -12931.684   -13087.498   -13087.498    301.43251    301.43251    68102.398    68102.398    676.01786    676.01786 
Loop time of 127.308 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.679 ns/day, 35.363 hours/ns, 7.855 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    | 126.19     | 126.19     | 126.19     |   0.0 | 99.12
Neigh   | 0.11988    | 0.11988    | 0.11988    |   0.0 |  0.09
Comm    | 0.20224    | 0.20224    | 0.20224    |   0.0 |  0.16
Output  | 0.00023117 | 0.00023117 | 0.00023117 |   0.0 |  0.00
Modify  | 0.6903     | 0.6903     | 0.6903     |   0.0 |  0.54
Other   |            | 0.1023     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8276.00 ave        8276 max        8276 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:      943732.0 ave      943732 max      943732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943732
Ave neighs/atom = 235.93300
Neighbor list builds = 1
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -12931.684   -12931.684   -13087.498   -13087.498    301.43251    301.43251    68102.398    68102.398    676.01786    676.01786 
    2000   -12946.784   -12946.784   -13094.533   -13094.533     285.8305     285.8305     68079.16     68079.16    82.908688    82.908688 
Loop time of 130.546 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.662 ns/day, 36.263 hours/ns, 7.660 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129.54     | 129.54     | 129.54     |   0.0 | 99.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20373    | 0.20373    | 0.20373    |   0.0 |  0.16
Output  | 0.00021533 | 0.00021533 | 0.00021533 |   0.0 |  0.00
Modify  | 0.70042    | 0.70042    | 0.70042    |   0.0 |  0.54
Other   |            | 0.1029     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8249.00 ave        8249 max        8249 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:      943182.0 ave      943182 max      943182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943182
Ave neighs/atom = 235.79550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -12946.784   -12946.784   -13094.533   -13094.533     285.8305     285.8305     68079.16     68079.16    82.908688    82.908688 
    3000   -12940.804   -12940.804    -13092.57    -13092.57    293.60069    293.60069    68088.323    68088.323    142.08034    142.08034 
Loop time of 130.686 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.661 ns/day, 36.302 hours/ns, 7.652 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129.68     | 129.68     | 129.68     |   0.0 | 99.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20273    | 0.20273    | 0.20273    |   0.0 |  0.16
Output  | 0.00021706 | 0.00021706 | 0.00021706 |   0.0 |  0.00
Modify  | 0.69734    | 0.69734    | 0.69734    |   0.0 |  0.53
Other   |            | 0.1026     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8251.00 ave        8251 max        8251 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:      943296.0 ave      943296 max      943296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943296
Ave neighs/atom = 235.82400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -12940.804   -12940.804    -13092.57    -13092.57    293.60069    293.60069    68088.323    68088.323    142.08034    142.08034 
    4000   -12940.576   -12940.576   -13092.051   -13092.051    293.03788    293.03788    68145.105    68145.105   -654.40259   -654.40259 
Loop time of 130.08 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.664 ns/day, 36.133 hours/ns, 7.688 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129.07     | 129.07     | 129.07     |   0.0 | 99.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20382    | 0.20382    | 0.20382    |   0.0 |  0.16
Output  | 0.00021443 | 0.00021443 | 0.00021443 |   0.0 |  0.00
Modify  | 0.70353    | 0.70353    | 0.70353    |   0.0 |  0.54
Other   |            | 0.1034     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8242.00 ave        8242 max        8242 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:      943428.0 ave      943428 max      943428 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943428
Ave neighs/atom = 235.85700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -12940.576   -12940.576   -13092.051   -13092.051    293.03788    293.03788    68145.105    68145.105   -654.40259   -654.40259 
    5000   -12944.407   -12944.407   -13096.359   -13096.359     293.9626     293.9626    68007.568    68007.568    858.84659    858.84659 
Loop time of 129.091 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.669 ns/day, 35.859 hours/ns, 7.746 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    | 128.07     | 128.07     | 128.07     |   0.0 | 99.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20369    | 0.20369    | 0.20369    |   0.0 |  0.16
Output  | 0.0002787  | 0.0002787  | 0.0002787  |   0.0 |  0.00
Modify  | 0.70955    | 0.70955    | 0.70955    |   0.0 |  0.55
Other   |            | 0.1034     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8230.00 ave        8230 max        8230 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:      942684.0 ave      942684 max      942684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 942684
Ave neighs/atom = 235.67100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.376301564208, Press = 28.78120059646
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -12944.407   -12944.407   -13096.359   -13096.359     293.9626     293.9626    68007.568    68007.568    858.84659    858.84659 
    6000   -12939.581   -12939.581   -13092.528   -13092.528    295.88494    295.88494    68185.791    68185.791   -1223.2284   -1223.2284 
Loop time of 130.918 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.660 ns/day, 36.366 hours/ns, 7.638 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129.87     | 129.87     | 129.87     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20702    | 0.20702    | 0.20702    |   0.0 |  0.16
Output  | 0.00018292 | 0.00018292 | 0.00018292 |   0.0 |  0.00
Modify  | 0.73777    | 0.73777    | 0.73777    |   0.0 |  0.56
Other   |            | 0.1041     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8254.00 ave        8254 max        8254 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:      944170.0 ave      944170 max      944170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 944170
Ave neighs/atom = 236.04250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.727652598864, Press = 10.1653001907718
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -12939.581   -12939.581   -13092.528   -13092.528    295.88494    295.88494    68185.791    68185.791   -1223.2284   -1223.2284 
    7000    -12945.15    -12945.15   -13096.381   -13096.381    292.56707    292.56707      68022.7      68022.7    663.23462    663.23462 
Loop time of 128.363 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.673 ns/day, 35.657 hours/ns, 7.790 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    | 127.34     | 127.34     | 127.34     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20166    | 0.20166    | 0.20166    |   0.0 |  0.16
Output  | 0.00018399 | 0.00018399 | 0.00018399 |   0.0 |  0.00
Modify  | 0.72073    | 0.72073    | 0.72073    |   0.0 |  0.56
Other   |            | 0.1032     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8248.00 ave        8248 max        8248 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:      942038.0 ave      942038 max      942038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 942038
Ave neighs/atom = 235.50950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.127224205316, Press = -5.5167421614359
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000    -12945.15    -12945.15   -13096.381   -13096.381    292.56707    292.56707      68022.7      68022.7    663.23462    663.23462 
    8000   -12938.721   -12938.721   -13089.947   -13089.947    292.55696    292.55696     68142.27     68142.27    -433.1519    -433.1519 
Loop time of 131.089 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.659 ns/day, 36.414 hours/ns, 7.628 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.06     | 130.06     | 130.06     |   0.0 | 99.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2027     | 0.2027     | 0.2027     |   0.0 |  0.15
Output  | 0.00017927 | 0.00017927 | 0.00017927 |   0.0 |  0.00
Modify  | 0.72706    | 0.72706    | 0.72706    |   0.0 |  0.55
Other   |            | 0.1025     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8233.00 ave        8233 max        8233 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:      944270.0 ave      944270 max      944270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 944270
Ave neighs/atom = 236.06750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.133642904038, Press = -10.0101581813473
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -12938.721   -12938.721   -13089.947   -13089.947    292.55696    292.55696     68142.27     68142.27    -433.1519    -433.1519 
    9000   -12945.807   -12945.807   -13098.631   -13098.631    295.64847    295.64847    68051.766    68051.766    42.556322    42.556322 
Loop time of 131.827 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.655 ns/day, 36.619 hours/ns, 7.586 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.79     | 130.79     | 130.79     |   0.0 | 99.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20403    | 0.20403    | 0.20403    |   0.0 |  0.15
Output  | 0.00017371 | 0.00017371 | 0.00017371 |   0.0 |  0.00
Modify  | 0.73068    | 0.73068    | 0.73068    |   0.0 |  0.55
Other   |            | 0.1032     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8250.00 ave        8250 max        8250 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:      942530.0 ave      942530 max      942530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 942530
Ave neighs/atom = 235.63250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.267367817313, Press = 3.14162568070067
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -12945.807   -12945.807   -13098.631   -13098.631    295.64847    295.64847    68051.766    68051.766    42.556322    42.556322 
   10000   -12938.638   -12938.638   -13093.147   -13093.147    298.90879    298.90879    68100.997    68100.997   -61.590997   -61.590997 
Loop time of 128.883 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.670 ns/day, 35.801 hours/ns, 7.759 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    | 127.85     | 127.85     | 127.85     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20326    | 0.20326    | 0.20326    |   0.0 |  0.16
Output  | 0.000226   | 0.000226   | 0.000226   |   0.0 |  0.00
Modify  | 0.72231    | 0.72231    | 0.72231    |   0.0 |  0.56
Other   |            | 0.103      |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8254.00 ave        8254 max        8254 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:      943662.0 ave      943662 max      943662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943662
Ave neighs/atom = 235.91550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.993906540829, Press = -6.43944549005179
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -12938.638   -12938.638   -13093.147   -13093.147    298.90879    298.90879    68100.997    68100.997   -61.590997   -61.590997 
   11000   -12944.978   -12944.978   -13095.896   -13095.896    291.96223    291.96223    68106.281    68106.281   -532.91952   -532.91952 
Loop time of 126.108 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.685 ns/day, 35.030 hours/ns, 7.930 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.09     | 125.09     | 125.09     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2008     | 0.2008     | 0.2008     |   0.0 |  0.16
Output  | 0.0001767  | 0.0001767  | 0.0001767  |   0.0 |  0.00
Modify  | 0.71229    | 0.71229    | 0.71229    |   0.0 |  0.56
Other   |            | 0.102      |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8263.00 ave        8263 max        8263 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:      943102.0 ave      943102 max      943102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943102
Ave neighs/atom = 235.77550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.143115693518, Press = 2.14862957920733
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -12944.978   -12944.978   -13095.896   -13095.896    291.96223    291.96223    68106.281    68106.281   -532.91952   -532.91952 
   12000   -12941.422   -12941.422   -13092.548   -13092.548    292.36296    292.36296     68069.45     68069.45    680.51375    680.51375 
Loop time of 125.565 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.688 ns/day, 34.879 hours/ns, 7.964 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    | 124.56     | 124.56     | 124.56     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19889    | 0.19889    | 0.19889    |   0.0 |  0.16
Output  | 0.00017859 | 0.00017859 | 0.00017859 |   0.0 |  0.00
Modify  | 0.7012     | 0.7012     | 0.7012     |   0.0 |  0.56
Other   |            | 0.102      |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8243.00 ave        8243 max        8243 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:      943094.0 ave      943094 max      943094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943094
Ave neighs/atom = 235.77350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.041486787367, Press = 4.85482334316117
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -12941.422   -12941.422   -13092.548   -13092.548    292.36296    292.36296     68069.45     68069.45    680.51375    680.51375 
   13000   -12942.405   -12942.405   -13095.476   -13095.476    296.12498    296.12498     67999.79     67999.79    1261.3504    1261.3504 
Loop time of 125.034 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.691 ns/day, 34.732 hours/ns, 7.998 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    | 124.03     | 124.03     | 124.03     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19825    | 0.19825    | 0.19825    |   0.0 |  0.16
Output  | 0.00017255 | 0.00017255 | 0.00017255 |   0.0 |  0.00
Modify  | 0.69966    | 0.69966    | 0.69966    |   0.0 |  0.56
Other   |            | 0.1028     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8244.00 ave        8244 max        8244 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:      943844.0 ave      943844 max      943844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943844
Ave neighs/atom = 235.96100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.106359969851, Press = -2.80038064135095
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -12942.405   -12942.405   -13095.476   -13095.476    296.12498    296.12498     67999.79     67999.79    1261.3504    1261.3504 
   14000   -12951.025   -12951.025   -13097.885   -13097.885    284.11083    284.11083    68098.076    68098.076   -581.13834   -581.13834 
Loop time of 129.599 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.667 ns/day, 36.000 hours/ns, 7.716 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    | 128.58     | 128.58     | 128.58     |   0.0 | 99.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20266    | 0.20266    | 0.20266    |   0.0 |  0.16
Output  | 0.00017755 | 0.00017755 | 0.00017755 |   0.0 |  0.00
Modify  | 0.71644    | 0.71644    | 0.71644    |   0.0 |  0.55
Other   |            | 0.1029     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8266.00 ave        8266 max        8266 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:      944686.0 ave      944686 max      944686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 944686
Ave neighs/atom = 236.17150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.88686815188, Press = -2.12413440108098
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -12951.025   -12951.025   -13097.885   -13097.885    284.11083    284.11083    68098.076    68098.076   -581.13834   -581.13834 
   15000   -12941.082   -12941.082     -13093.3     -13093.3    294.47513    294.47513    68111.254    68111.254   -269.48881   -269.48881 
Loop time of 127.39 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.678 ns/day, 35.386 hours/ns, 7.850 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    | 126.37     | 126.37     | 126.37     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20138    | 0.20138    | 0.20138    |   0.0 |  0.16
Output  | 0.00017556 | 0.00017556 | 0.00017556 |   0.0 |  0.00
Modify  | 0.71634    | 0.71634    | 0.71634    |   0.0 |  0.56
Other   |            | 0.1023     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8230.00 ave        8230 max        8230 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:      942954.0 ave      942954 max      942954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 942954
Ave neighs/atom = 235.73850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.756628321072, Press = 1.07108365408935
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -12941.082   -12941.082     -13093.3     -13093.3    294.47513    294.47513    68111.254    68111.254   -269.48881   -269.48881 
   16000   -12948.689   -12948.689   -13095.825   -13095.825    284.64498    284.64498    68023.796    68023.796    662.80153    662.80153 
Loop time of 129.586 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.667 ns/day, 35.996 hours/ns, 7.717 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    | 128.55     | 128.55     | 128.55     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2029     | 0.2029     | 0.2029     |   0.0 |  0.16
Output  | 0.00016853 | 0.00016853 | 0.00016853 |   0.0 |  0.00
Modify  | 0.73217    | 0.73217    | 0.73217    |   0.0 |  0.57
Other   |            | 0.1038     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8241.00 ave        8241 max        8241 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:      943194.0 ave      943194 max      943194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943194
Ave neighs/atom = 235.79850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.706806495314, Press = -0.857907439289232
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -12948.689   -12948.689   -13095.825   -13095.825    284.64498    284.64498    68023.796    68023.796    662.80153    662.80153 
   17000   -12942.355   -12942.355   -13093.598   -13093.598    292.59111    292.59111    68065.897    68065.897    456.31759    456.31759 
Loop time of 129.416 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.668 ns/day, 35.949 hours/ns, 7.727 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    | 128.39     | 128.39     | 128.39     |   0.0 | 99.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20349    | 0.20349    | 0.20349    |   0.0 |  0.16
Output  | 0.00022091 | 0.00022091 | 0.00022091 |   0.0 |  0.00
Modify  | 0.71887    | 0.71887    | 0.71887    |   0.0 |  0.56
Other   |            | 0.1027     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8260.00 ave        8260 max        8260 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:      944034.0 ave      944034 max      944034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 944034
Ave neighs/atom = 236.00850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.574691169734, Press = -2.0246872979381
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -12942.355   -12942.355   -13093.598   -13093.598    292.59111    292.59111    68065.897    68065.897    456.31759    456.31759 
   18000    -12940.75    -12940.75   -13091.758   -13091.758    292.13525    292.13525    68191.528    68191.528    -1298.815    -1298.815 
Loop time of 128.114 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.674 ns/day, 35.587 hours/ns, 7.806 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    | 127.1      | 127.1      | 127.1      |   0.0 | 99.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20131    | 0.20131    | 0.20131    |   0.0 |  0.16
Output  | 0.00018226 | 0.00018226 | 0.00018226 |   0.0 |  0.00
Modify  | 0.71193    | 0.71193    | 0.71193    |   0.0 |  0.56
Other   |            | 0.1027     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8262.00 ave        8262 max        8262 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:      943846.0 ave      943846 max      943846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943846
Ave neighs/atom = 235.96150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.708183956037, Press = -0.423329000243953
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000    -12940.75    -12940.75   -13091.758   -13091.758    292.13525    292.13525    68191.528    68191.528    -1298.815    -1298.815 
   19000   -12947.763   -12947.763   -13096.032   -13096.032    286.83735    286.83735    68029.532    68029.532    544.27611    544.27611 
Loop time of 132.34 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.653 ns/day, 36.761 hours/ns, 7.556 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.3      | 131.3      | 131.3      |   0.0 | 99.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20508    | 0.20508    | 0.20508    |   0.0 |  0.15
Output  | 0.00017753 | 0.00017753 | 0.00017753 |   0.0 |  0.00
Modify  | 0.72724    | 0.72724    | 0.72724    |   0.0 |  0.55
Other   |            | 0.104      |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8240.00 ave        8240 max        8240 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:      941868.0 ave      941868 max      941868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 941868
Ave neighs/atom = 235.46700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.629787775104, Press = 0.293316388728486
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -12947.763   -12947.763   -13096.032   -13096.032    286.83735    286.83735    68029.532    68029.532    544.27611    544.27611 
   20000   -12939.084   -12939.084   -13090.437   -13090.437    292.80408    292.80408    68134.559    68134.559   -229.14036   -229.14036 
Loop time of 132.73 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.651 ns/day, 36.869 hours/ns, 7.534 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.69     | 131.69     | 131.69     |   0.0 | 99.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20773    | 0.20773    | 0.20773    |   0.0 |  0.16
Output  | 0.00018614 | 0.00018614 | 0.00018614 |   0.0 |  0.00
Modify  | 0.72853    | 0.72853    | 0.72853    |   0.0 |  0.55
Other   |            | 0.1037     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8262.00 ave        8262 max        8262 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:      944184.0 ave      944184 max      944184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 944184
Ave neighs/atom = 236.04600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.604106198277, Press = -0.275091733114489
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -12939.084   -12939.084   -13090.437   -13090.437    292.80408    292.80408    68134.559    68134.559   -229.14036   -229.14036 
   21000   -12945.226   -12945.226   -13097.146   -13097.146     293.8979     293.8979    68082.742    68082.742   -314.78627   -314.78627 
Loop time of 125.784 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.687 ns/day, 34.940 hours/ns, 7.950 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    | 124.78     | 124.78     | 124.78     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20147    | 0.20147    | 0.20147    |   0.0 |  0.16
Output  | 0.00017832 | 0.00017832 | 0.00017832 |   0.0 |  0.00
Modify  | 0.70553    | 0.70553    | 0.70553    |   0.0 |  0.56
Other   |            | 0.1018     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8257.00 ave        8257 max        8257 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:      942562.0 ave      942562 max      942562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 942562
Ave neighs/atom = 235.64050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.581771494194, Press = -0.0161067968520522
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -12945.226   -12945.226   -13097.146   -13097.146     293.8979     293.8979    68082.742    68082.742   -314.78627   -314.78627 
   22000   -12940.252   -12940.252   -13093.644   -13093.644    296.74695    296.74695    68156.551    68156.551   -885.67488   -885.67488 
Loop time of 127.816 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.676 ns/day, 35.504 hours/ns, 7.824 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    | 126.79     | 126.79     | 126.79     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20249    | 0.20249    | 0.20249    |   0.0 |  0.16
Output  | 0.00022568 | 0.00022568 | 0.00022568 |   0.0 |  0.00
Modify  | 0.71933    | 0.71933    | 0.71933    |   0.0 |  0.56
Other   |            | 0.1034     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8254.00 ave        8254 max        8254 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:      943220.0 ave      943220 max      943220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943220
Ave neighs/atom = 235.80500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.570079345649, Press = 0.692168845034956
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -12940.252   -12940.252   -13093.644   -13093.644    296.74695    296.74695    68156.551    68156.551   -885.67488   -885.67488 
   23000   -12944.339   -12944.339   -13095.212   -13095.212     291.8729     291.8729    68053.262    68053.262    333.67315    333.67315 
Loop time of 128.54 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.672 ns/day, 35.706 hours/ns, 7.780 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    | 127.52     | 127.52     | 127.52     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20175    | 0.20175    | 0.20175    |   0.0 |  0.16
Output  | 0.000176   | 0.000176   | 0.000176   |   0.0 |  0.00
Modify  | 0.71793    | 0.71793    | 0.71793    |   0.0 |  0.56
Other   |            | 0.1023     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8238.00 ave        8238 max        8238 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:      942354.0 ave      942354 max      942354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 942354
Ave neighs/atom = 235.58850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.554489868159, Press = 0.628989244284908
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -12944.339   -12944.339   -13095.212   -13095.212     291.8729     291.8729    68053.262    68053.262    333.67315    333.67315 
   24000    -12941.61    -12941.61   -13094.068   -13094.068    294.93923    294.93923    68152.014    68152.014   -925.09564   -925.09564 
Loop time of 132.031 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.654 ns/day, 36.675 hours/ns, 7.574 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.99     | 130.99     | 130.99     |   0.0 | 99.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20554    | 0.20554    | 0.20554    |   0.0 |  0.16
Output  | 0.00018174 | 0.00018174 | 0.00018174 |   0.0 |  0.00
Modify  | 0.73514    | 0.73514    | 0.73514    |   0.0 |  0.56
Other   |            | 0.1039     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8239.00 ave        8239 max        8239 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:      943998.0 ave      943998 max      943998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943998
Ave neighs/atom = 235.99950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.557975985039, Press = -2.00642692927571
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000    -12941.61    -12941.61   -13094.068   -13094.068    294.93923    294.93923    68152.014    68152.014   -925.09564   -925.09564 
   25000   -12943.525   -12943.525   -13093.586   -13093.586    290.30245    290.30245    68110.193    68110.193   -197.68013   -197.68013 
Loop time of 129.867 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.665 ns/day, 36.074 hours/ns, 7.700 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    | 128.85     | 128.85     | 128.85     |   0.0 | 99.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20088    | 0.20088    | 0.20088    |   0.0 |  0.15
Output  | 0.00019482 | 0.00019482 | 0.00019482 |   0.0 |  0.00
Modify  | 0.71707    | 0.71707    | 0.71707    |   0.0 |  0.55
Other   |            | 0.1028     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8242.00 ave        8242 max        8242 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:      942556.0 ave      942556 max      942556 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 942556
Ave neighs/atom = 235.63900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.583705777916, Press = 2.32261575121449
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -12943.525   -12943.525   -13093.586   -13093.586    290.30245    290.30245    68110.193    68110.193   -197.68013   -197.68013 
   26000   -12940.027   -12940.027   -13092.292   -13092.292    294.56778    294.56778    68061.295    68061.295    725.92936    725.92936 
Loop time of 128.754 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.671 ns/day, 35.765 hours/ns, 7.767 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    | 127.72     | 127.72     | 127.72     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20237    | 0.20237    | 0.20237    |   0.0 |  0.16
Output  | 0.00022727 | 0.00022727 | 0.00022727 |   0.0 |  0.00
Modify  | 0.72347    | 0.72347    | 0.72347    |   0.0 |  0.56
Other   |            | 0.1031     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8235.00 ave        8235 max        8235 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:      942748.0 ave      942748 max      942748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 942748
Ave neighs/atom = 235.68700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.607767337853, Press = -0.822502186395762
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -12940.027   -12940.027   -13092.292   -13092.292    294.56778    294.56778    68061.295    68061.295    725.92936    725.92936 
   27000   -12942.092   -12942.092    -13092.84    -13092.84    291.63333    291.63333    68118.031    68118.031   -229.15286   -229.15286 
Loop time of 131.342 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.658 ns/day, 36.484 hours/ns, 7.614 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.3      | 130.3      | 130.3      |   0.0 | 99.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20307    | 0.20307    | 0.20307    |   0.0 |  0.15
Output  | 0.00017847 | 0.00017847 | 0.00017847 |   0.0 |  0.00
Modify  | 0.73029    | 0.73029    | 0.73029    |   0.0 |  0.56
Other   |            | 0.1041     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8274.00 ave        8274 max        8274 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:      943712.0 ave      943712 max      943712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943712
Ave neighs/atom = 235.92800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.651094917563, Press = -0.403824015477798
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -12942.092   -12942.092    -13092.84    -13092.84    291.63333    291.63333    68118.031    68118.031   -229.15286   -229.15286 
   28000   -12950.374   -12950.374   -13097.556   -13097.556    284.73382    284.73382    67999.419    67999.419    987.70392    987.70392 
Loop time of 126.796 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.681 ns/day, 35.221 hours/ns, 7.887 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.78     | 125.78     | 125.78     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19974    | 0.19974    | 0.19974    |   0.0 |  0.16
Output  | 0.00022652 | 0.00022652 | 0.00022652 |   0.0 |  0.00
Modify  | 0.70879    | 0.70879    | 0.70879    |   0.0 |  0.56
Other   |            | 0.1021     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8257.00 ave        8257 max        8257 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:      942990.0 ave      942990 max      942990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 942990
Ave neighs/atom = 235.74750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.650530227524, Press = -0.51774127480989
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -12950.374   -12950.374   -13097.556   -13097.556    284.73382    284.73382    67999.419    67999.419    987.70392    987.70392 
   29000   -12941.377   -12941.377   -13093.565   -13093.565    294.41649    294.41649    68132.306    68132.306   -468.35826   -468.35826 
Loop time of 121.259 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.713 ns/day, 33.683 hours/ns, 8.247 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    | 120.27     | 120.27     | 120.27     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19626    | 0.19626    | 0.19626    |   0.0 |  0.16
Output  | 0.00023284 | 0.00023284 | 0.00023284 |   0.0 |  0.00
Modify  | 0.69468    | 0.69468    | 0.69468    |   0.0 |  0.57
Other   |            | 0.1023     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8256.00 ave        8256 max        8256 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:      944604.0 ave      944604 max      944604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 944604
Ave neighs/atom = 236.15100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.573850916643, Press = -1.72032021484431
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -12941.377   -12941.377   -13093.565   -13093.565    294.41649    294.41649    68132.306    68132.306   -468.35826   -468.35826 
   30000   -12944.612   -12944.612    -13096.66    -13096.66    294.14726    294.14726    68160.688    68160.688   -1407.6564   -1407.6564 
Loop time of 123.966 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.697 ns/day, 34.435 hours/ns, 8.067 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    | 122.96     | 122.96     | 122.96     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2003     | 0.2003     | 0.2003     |   0.0 |  0.16
Output  | 0.00048524 | 0.00048524 | 0.00048524 |   0.0 |  0.00
Modify  | 0.7017     | 0.7017     | 0.7017     |   0.0 |  0.57
Other   |            | 0.1018     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8235.00 ave        8235 max        8235 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:      942508.0 ave      942508 max      942508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 942508
Ave neighs/atom = 235.62700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.564719154924, Press = 1.05736056400166
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -12944.612   -12944.612    -13096.66    -13096.66    294.14726    294.14726    68160.688    68160.688   -1407.6564   -1407.6564 
   31000    -12938.88    -12938.88   -13091.327   -13091.327    294.91935    294.91935     68079.48     68079.48    554.37514    554.37514 
Loop time of 124.168 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.696 ns/day, 34.491 hours/ns, 8.054 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    | 123.17     | 123.17     | 123.17     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19839    | 0.19839    | 0.19839    |   0.0 |  0.16
Output  | 0.00017794 | 0.00017794 | 0.00017794 |   0.0 |  0.00
Modify  | 0.70003    | 0.70003    | 0.70003    |   0.0 |  0.56
Other   |            | 0.1024     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8247.00 ave        8247 max        8247 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:      942284.0 ave      942284 max      942284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 942284
Ave neighs/atom = 235.57100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.548639903248, Press = -0.0214181124476779
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000    -12938.88    -12938.88   -13091.327   -13091.327    294.91935    294.91935     68079.48     68079.48    554.37514    554.37514 
   32000   -12945.316   -12945.316   -13094.924   -13094.924    289.42767    289.42767    68084.345    68084.345   -110.31235   -110.31235 
Loop time of 128.261 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.674 ns/day, 35.628 hours/ns, 7.797 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    | 127.23     | 127.23     | 127.23     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20357    | 0.20357    | 0.20357    |   0.0 |  0.16
Output  | 0.00022144 | 0.00022144 | 0.00022144 |   0.0 |  0.00
Modify  | 0.72239    | 0.72239    | 0.72239    |   0.0 |  0.56
Other   |            | 0.1033     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8236.00 ave        8236 max        8236 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:      943530.0 ave      943530 max      943530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943530
Ave neighs/atom = 235.88250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.570194488267, Press = -0.304351545716138
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -12945.316   -12945.316   -13094.924   -13094.924    289.42767    289.42767    68084.345    68084.345   -110.31235   -110.31235 
   33000   -12936.951   -12936.951   -13090.464   -13090.464    296.98303    296.98303     68052.01     68052.01    1029.0731    1029.0731 
Loop time of 126.304 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.684 ns/day, 35.084 hours/ns, 7.917 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.29     | 125.29     | 125.29     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20122    | 0.20122    | 0.20122    |   0.0 |  0.16
Output  | 0.00018125 | 0.00018125 | 0.00018125 |   0.0 |  0.00
Modify  | 0.71073    | 0.71073    | 0.71073    |   0.0 |  0.56
Other   |            | 0.1023     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8246.00 ave        8246 max        8246 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:      943444.0 ave      943444 max      943444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943444
Ave neighs/atom = 235.86100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.634556655757, Press = 0.950793042306965
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -12936.951   -12936.951   -13090.464   -13090.464    296.98303    296.98303     68052.01     68052.01    1029.0731    1029.0731 
   34000   -12942.279   -12942.279   -13095.297   -13095.297    296.02253    296.02253    68050.597    68050.597    525.35509    525.35509 
Loop time of 125.506 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.688 ns/day, 34.863 hours/ns, 7.968 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    | 124.5      | 124.5      | 124.5      |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20103    | 0.20103    | 0.20103    |   0.0 |  0.16
Output  | 0.00022682 | 0.00022682 | 0.00022682 |   0.0 |  0.00
Modify  | 0.7028     | 0.7028     | 0.7028     |   0.0 |  0.56
Other   |            | 0.1034     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8272.00 ave        8272 max        8272 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:      943964.0 ave      943964 max      943964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943964
Ave neighs/atom = 235.99100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.671590571258, Press = -1.17511033313091
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -12942.279   -12942.279   -13095.297   -13095.297    296.02253    296.02253    68050.597    68050.597    525.35509    525.35509 
   35000   -12939.236   -12939.236   -13088.609   -13088.609      288.971      288.971    68143.002    68143.002   -92.470742   -92.470742 
Loop time of 125.675 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.687 ns/day, 34.910 hours/ns, 7.957 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    | 124.67     | 124.67     | 124.67     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19899    | 0.19899    | 0.19899    |   0.0 |  0.16
Output  | 0.00018569 | 0.00018569 | 0.00018569 |   0.0 |  0.00
Modify  | 0.69979    | 0.69979    | 0.69979    |   0.0 |  0.56
Other   |            | 0.1016     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8256.00 ave        8256 max        8256 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:      943554.0 ave      943554 max      943554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943554
Ave neighs/atom = 235.88850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.746914110701, Press = 0.67385824277849
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -12939.236   -12939.236   -13088.609   -13088.609      288.971      288.971    68143.002    68143.002   -92.470742   -92.470742 
   36000   -12941.988   -12941.988   -13095.333   -13095.333    296.65562    296.65562    68053.703    68053.703    174.03326    174.03326 
Loop time of 128.942 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.670 ns/day, 35.817 hours/ns, 7.755 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    | 127.91     | 127.91     | 127.91     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20383    | 0.20383    | 0.20383    |   0.0 |  0.16
Output  | 0.00023834 | 0.00023834 | 0.00023834 |   0.0 |  0.00
Modify  | 0.72689    | 0.72689    | 0.72689    |   0.0 |  0.56
Other   |            | 0.1039     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8223.00 ave        8223 max        8223 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:      942998.0 ave      942998 max      942998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 942998
Ave neighs/atom = 235.74950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.760844527264, Press = -0.281879199726735
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -12941.988   -12941.988   -13095.333   -13095.333    296.65562    296.65562    68053.703    68053.703    174.03326    174.03326 
   37000   -12941.304   -12941.304   -13093.303   -13093.303    294.05275    294.05275    68103.614    68103.614   -189.32834   -189.32834 
Loop time of 125.365 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.689 ns/day, 34.824 hours/ns, 7.977 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.35     | 124.35     | 124.35     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19989    | 0.19989    | 0.19989    |   0.0 |  0.16
Output  | 0.00017512 | 0.00017512 | 0.00017512 |   0.0 |  0.00
Modify  | 0.70981    | 0.70981    | 0.70981    |   0.0 |  0.57
Other   |            | 0.1028     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8244.00 ave        8244 max        8244 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:      943726.0 ave      943726 max      943726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943726
Ave neighs/atom = 235.93150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.760010908961, Press = 0.0915579276624827
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -12941.304   -12941.304   -13093.303   -13093.303    294.05275    294.05275    68103.614    68103.614   -189.32834   -189.32834 
   38000   -12944.716   -12944.716   -13093.193   -13093.193    287.23802    287.23802    68081.312    68081.312    160.02821    160.02821 
Loop time of 125.711 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.687 ns/day, 34.920 hours/ns, 7.955 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.7      | 124.7      | 124.7      |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20019    | 0.20019    | 0.20019    |   0.0 |  0.16
Output  | 0.00018137 | 0.00018137 | 0.00018137 |   0.0 |  0.00
Modify  | 0.70792    | 0.70792    | 0.70792    |   0.0 |  0.56
Other   |            | 0.1031     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8285.00 ave        8285 max        8285 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:      942962.0 ave      942962 max      942962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 942962
Ave neighs/atom = 235.74050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.7762554478, Press = 0.249325447208199
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -12944.716   -12944.716   -13093.193   -13093.193    287.23802    287.23802    68081.312    68081.312    160.02821    160.02821 
   39000   -12939.901   -12939.901   -13092.801   -13092.801    295.79492    295.79492    68084.512    68084.512    348.91619    348.91619 
Loop time of 124.592 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.693 ns/day, 34.609 hours/ns, 8.026 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    | 123.58     | 123.58     | 123.58     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19987    | 0.19987    | 0.19987    |   0.0 |  0.16
Output  | 0.00017748 | 0.00017748 | 0.00017748 |   0.0 |  0.00
Modify  | 0.70576    | 0.70576    | 0.70576    |   0.0 |  0.57
Other   |            | 0.1027     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8240.00 ave        8240 max        8240 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:      943492.0 ave      943492 max      943492 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943492
Ave neighs/atom = 235.87300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.815493703955, Press = -1.07724341816346
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -12939.901   -12939.901   -13092.801   -13092.801    295.79492    295.79492    68084.512    68084.512    348.91619    348.91619 
   40000   -12942.162   -12942.162   -13092.179   -13092.179    290.21708    290.21708    68145.818    68145.818   -803.40217   -803.40217 
Loop time of 125.197 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.690 ns/day, 34.777 hours/ns, 7.987 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    | 124.19     | 124.19     | 124.19     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19883    | 0.19883    | 0.19883    |   0.0 |  0.16
Output  | 0.0001786  | 0.0001786  | 0.0001786  |   0.0 |  0.00
Modify  | 0.70124    | 0.70124    | 0.70124    |   0.0 |  0.56
Other   |            | 0.102      |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8229.00 ave        8229 max        8229 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:      943366.0 ave      943366 max      943366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943366
Ave neighs/atom = 235.84150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.826479419414, Press = 0.127254841644261
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -12942.162   -12942.162   -13092.179   -13092.179    290.21708    290.21708    68145.818    68145.818   -803.40217   -803.40217 
   41000   -12934.068   -12934.068   -13091.933   -13091.933    305.39915    305.39915    67983.729    67983.729    1850.0237    1850.0237 
Loop time of 121.94 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.709 ns/day, 33.872 hours/ns, 8.201 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    | 120.95     | 120.95     | 120.95     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19852    | 0.19852    | 0.19852    |   0.0 |  0.16
Output  | 0.00018061 | 0.00018061 | 0.00018061 |   0.0 |  0.00
Modify  | 0.6914     | 0.6914     | 0.6914     |   0.0 |  0.57
Other   |            | 0.1026     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8280.00 ave        8280 max        8280 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:      942522.0 ave      942522 max      942522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 942522
Ave neighs/atom = 235.63050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.89599802793, Press = 0.844775245022703
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -12934.068   -12934.068   -13091.933   -13091.933    305.39915    305.39915    67983.729    67983.729    1850.0237    1850.0237 
   42000   -12942.765   -12942.765   -13093.723   -13093.723    292.03876    292.03876    68045.392    68045.392    462.68933    462.68933 
Loop time of 125.55 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.688 ns/day, 34.875 hours/ns, 7.965 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    | 124.55     | 124.55     | 124.55     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19998    | 0.19998    | 0.19998    |   0.0 |  0.16
Output  | 0.00017874 | 0.00017874 | 0.00017874 |   0.0 |  0.00
Modify  | 0.6961     | 0.6961     | 0.6961     |   0.0 |  0.55
Other   |            | 0.1028     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8259.00 ave        8259 max        8259 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:      944710.0 ave      944710 max      944710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 944710
Ave neighs/atom = 236.17750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.934091487096, Press = -1.09141621341294
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 = 10
  ghost atom cutoff = 10
  binsize = 5, bins = 9 9 9
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 10
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 7.005 | 7.005 | 7.005 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -12942.765   -12942.765   -13093.723   -13093.723    292.03876    292.03876    68045.392    68045.392    462.68933    462.68933 
   43000   -12940.193   -12940.193   -13092.217   -13092.217    294.10141    294.10141    68178.129    68178.129   -1091.3985   -1091.3985 
Loop time of 122.249 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.707 ns/day, 33.958 hours/ns, 8.180 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    | 121.26     | 121.26     | 121.26     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19382    | 0.19382    | 0.19382    |   0.0 |  0.16
Output  | 0.00022898 | 0.00022898 | 0.00022898 |   0.0 |  0.00
Modify  | 0.69719    | 0.69719    | 0.69719    |   0.0 |  0.57
Other   |            | 0.1025     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8236.00 ave        8236 max        8236 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:      944096.0 ave      944096 max      944096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0