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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_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   -13116.497   -13116.497   -13247.353   -13247.353       253.15       253.15    66161.194    66161.194    2112.5621    2112.5621 
    1000   -12974.761   -12974.761   -13109.555   -13109.555    260.76885    260.76885    67866.605    67866.605    1133.3731    1133.3731 
Loop time of 123.516 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.700 ns/day, 34.310 hours/ns, 8.096 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.51     | 122.51     | 122.51     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20423    | 0.20423    | 0.20423    |   0.0 |  0.17
Output  | 0.00022412 | 0.00022412 | 0.00022412 |   0.0 |  0.00
Modify  | 0.69556    | 0.69556    | 0.69556    |   0.0 |  0.56
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:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      992000.0 ave      992000 max      992000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 992000
Ave neighs/atom = 248.00000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 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   -12974.761   -12974.761   -13109.555   -13109.555    260.76885    260.76885    67866.605    67866.605    1133.3731    1133.3731 
    2000   -12987.673   -12987.673   -13115.287   -13115.287    246.87723    246.87723    67896.233    67896.233   -187.06903   -187.06903 
Loop time of 128.402 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.673 ns/day, 35.667 hours/ns, 7.788 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.39     | 127.39     | 127.39     |   0.0 | 99.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20329    | 0.20329    | 0.20329    |   0.0 |  0.16
Output  | 0.00026587 | 0.00026587 | 0.00026587 |   0.0 |  0.00
Modify  | 0.70207    | 0.70207    | 0.70207    |   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:        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:      946376.0 ave      946376 max      946376 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946376
Ave neighs/atom = 236.59400
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   -12987.673   -12987.673   -13115.287   -13115.287    246.87723    246.87723    67896.233    67896.233   -187.06903   -187.06903 
    3000   -12982.514   -12982.514   -13114.398   -13114.398    255.13735    255.13735    67886.122    67886.122    11.116059    11.116059 
Loop time of 130.206 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129.2      | 129.2      | 129.2      |   0.0 | 99.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20455    | 0.20455    | 0.20455    |   0.0 |  0.16
Output  | 0.00021953 | 0.00021953 | 0.00021953 |   0.0 |  0.00
Modify  | 0.69871    | 0.69871    | 0.69871    |   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:        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:      945770.0 ave      945770 max      945770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945770
Ave neighs/atom = 236.44250
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   -12982.514   -12982.514   -13114.398   -13114.398    255.13735    255.13735    67886.122    67886.122    11.116059    11.116059 
    4000   -12982.261   -12982.261   -13112.805   -13112.805    252.54679    252.54679    67968.229    67968.229    -962.9359    -962.9359 
Loop time of 133.341 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.648 ns/day, 37.039 hours/ns, 7.500 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    | 132.3      | 132.3      | 132.3      |   0.0 | 99.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20831    | 0.20831    | 0.20831    |   0.0 |  0.16
Output  | 0.00026022 | 0.00026022 | 0.00026022 |   0.0 |  0.00
Modify  | 0.72458    | 0.72458    | 0.72458    |   0.0 |  0.54
Other   |            | 0.1043     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8237.00 ave        8237 max        8237 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:      946174.0 ave      946174 max      946174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946174
Ave neighs/atom = 236.54350
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   -12982.261   -12982.261   -13112.805   -13112.805    252.54679    252.54679    67968.229    67968.229    -962.9359    -962.9359 
    5000   -12986.134   -12986.134   -13114.676   -13114.676    248.67459    248.67459    67904.636    67904.636   -230.69026   -230.69026 
Loop time of 130.99 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.660 ns/day, 36.386 hours/ns, 7.634 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.97     | 129.97     | 129.97     |   0.0 | 99.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20487    | 0.20487    | 0.20487    |   0.0 |  0.16
Output  | 0.00017757 | 0.00017757 | 0.00017757 |   0.0 |  0.00
Modify  | 0.70858    | 0.70858    | 0.70858    |   0.0 |  0.54
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:        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:      944838.0 ave      944838 max      944838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 944838
Ave neighs/atom = 236.20950
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 = 251.814473785465, Press = 493.701833117349
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   -12986.134   -12986.134   -13114.676   -13114.676    248.67459    248.67459    67904.636    67904.636   -230.69026   -230.69026 
    6000   -12981.528   -12981.528   -13112.579   -13112.579    253.52668    253.52668    67952.688    67952.688   -688.48309   -688.48309 
Loop time of 125.039 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.691 ns/day, 34.733 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.02     | 124.02     | 124.02     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20229    | 0.20229    | 0.20229    |   0.0 |  0.16
Output  | 0.00017799 | 0.00017799 | 0.00017799 |   0.0 |  0.00
Modify  | 0.71282    | 0.71282    | 0.71282    |   0.0 |  0.57
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:        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:      945800.0 ave      945800 max      945800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945800
Ave neighs/atom = 236.45000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.939355576322, Press = 37.5213016887963
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   -12981.528   -12981.528   -13112.579   -13112.579    253.52668    253.52668    67952.688    67952.688   -688.48309   -688.48309 
    7000   -12986.789   -12986.789   -13116.336   -13116.336    250.61797    250.61797    67876.157    67876.157     39.34724     39.34724 
Loop time of 124.883 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.692 ns/day, 34.690 hours/ns, 8.007 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.87     | 123.87     | 123.87     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20085    | 0.20085    | 0.20085    |   0.0 |  0.16
Output  | 0.00018865 | 0.00018865 | 0.00018865 |   0.0 |  0.00
Modify  | 0.71029    | 0.71029    | 0.71029    |   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:        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:      945132.0 ave      945132 max      945132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945132
Ave neighs/atom = 236.28300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.063725439918, Press = 20.5012732476782
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   -12986.789   -12986.789   -13116.336   -13116.336    250.61797    250.61797    67876.157    67876.157     39.34724     39.34724 
    8000   -12980.627   -12980.627   -13113.477   -13113.477    257.00741    257.00741    67916.416    67916.416   -303.19623   -303.19623 
Loop time of 127.386 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.678 ns/day, 35.385 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.2019     | 0.2019     | 0.2019     |   0.0 |  0.16
Output  | 0.00031715 | 0.00031715 | 0.00031715 |   0.0 |  0.00
Modify  | 0.7142     | 0.7142     | 0.7142     |   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:        8231.00 ave        8231 max        8231 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:      946236.0 ave      946236 max      946236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946236
Ave neighs/atom = 236.55900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.182904956321, Press = 17.2923363421049
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   -12980.627   -12980.627   -13113.477   -13113.477    257.00741    257.00741    67916.416    67916.416   -303.19623   -303.19623 
    9000   -12985.081   -12985.081   -13114.826   -13114.826    251.00082    251.00082    67848.163    67848.163    659.01142    659.01142 
Loop time of 130.09 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.664 ns/day, 36.136 hours/ns, 7.687 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.05     | 129.05     | 129.05     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20535    | 0.20535    | 0.20535    |   0.0 |  0.16
Output  | 0.00022334 | 0.00022334 | 0.00022334 |   0.0 |  0.00
Modify  | 0.735      | 0.735      | 0.735      |   0.0 |  0.56
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:        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:      945518.0 ave      945518 max      945518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945518
Ave neighs/atom = 236.37950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.333729577616, Press = 10.8014902448486
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   -12985.081   -12985.081   -13114.826   -13114.826    251.00082    251.00082    67848.163    67848.163    659.01142    659.01142 
   10000   -12984.464   -12984.464   -13116.911   -13116.911    256.22852    256.22852    67846.408    67846.408     504.9093     504.9093 
Loop time of 128.967 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.670 ns/day, 35.824 hours/ns, 7.754 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.94     | 127.94     | 127.94     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20451    | 0.20451    | 0.20451    |   0.0 |  0.16
Output  | 0.00017649 | 0.00017649 | 0.00017649 |   0.0 |  0.00
Modify  | 0.72219    | 0.72219    | 0.72219    |   0.0 |  0.56
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:        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:      946776.0 ave      946776 max      946776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946776
Ave neighs/atom = 236.69400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 253.313410581305, Press = 2.35954630017765
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   -12984.464   -12984.464   -13116.911   -13116.911    256.22852    256.22852    67846.408    67846.408     504.9093     504.9093 
   11000   -12983.887   -12983.887   -13114.299   -13114.299    252.29026    252.29026    67881.635    67881.635    314.87761    314.87761 
Loop time of 127.321 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.679 ns/day, 35.367 hours/ns, 7.854 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.3      | 126.3      | 126.3      |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20367    | 0.20367    | 0.20367    |   0.0 |  0.16
Output  | 0.00017693 | 0.00017693 | 0.00017693 |   0.0 |  0.00
Modify  | 0.7194     | 0.7194     | 0.7194     |   0.0 |  0.57
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:        8227.00 ave        8227 max        8227 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:      946692.0 ave      946692 max      946692 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946692
Ave neighs/atom = 236.67300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.963993412646, Press = 1.95100709557533
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   -12983.887   -12983.887   -13114.299   -13114.299    252.29026    252.29026    67881.635    67881.635    314.87761    314.87761 
   12000   -12986.609   -12986.609   -13115.669   -13115.669     249.6766     249.6766     67878.23     67878.23   -51.612475   -51.612475 
Loop time of 123.969 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.697 ns/day, 34.436 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.97     | 122.97     | 122.97     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19874    | 0.19874    | 0.19874    |   0.0 |  0.16
Output  | 0.00018298 | 0.00018298 | 0.00018298 |   0.0 |  0.00
Modify  | 0.70137    | 0.70137    | 0.70137    |   0.0 |  0.57
Other   |            | 0.1022     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8258.00 ave        8258 max        8258 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:      946150.0 ave      946150 max      946150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946150
Ave neighs/atom = 236.53750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.932026000726, Press = 2.54657976953845
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   -12986.609   -12986.609   -13115.669   -13115.669     249.6766     249.6766     67878.23     67878.23   -51.612475   -51.612475 
   13000   -12981.002   -12981.002   -13112.585   -13112.585    254.55768    254.55768     67833.47     67833.47    1182.5438    1182.5438 
Loop time of 124.259 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.695 ns/day, 34.516 hours/ns, 8.048 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.26     | 123.26     | 123.26     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19909    | 0.19909    | 0.19909    |   0.0 |  0.16
Output  | 0.00017871 | 0.00017871 | 0.00017871 |   0.0 |  0.00
Modify  | 0.70118    | 0.70118    | 0.70118    |   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:        8268.00 ave        8268 max        8268 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:      946242.0 ave      946242 max      946242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946242
Ave neighs/atom = 236.56050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.964883721722, Press = 3.98497891909125
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   -12981.002   -12981.002   -13112.585   -13112.585    254.55768    254.55768     67833.47     67833.47    1182.5438    1182.5438 
   14000   -12987.538   -12987.538   -13115.972   -13115.972    248.46421    248.46421    67854.331    67854.331    345.09085    345.09085 
Loop time of 127.402 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.678 ns/day, 35.389 hours/ns, 7.849 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.38     | 126.38     | 126.38     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20227    | 0.20227    | 0.20227    |   0.0 |  0.16
Output  | 0.0003132  | 0.0003132  | 0.0003132  |   0.0 |  0.00
Modify  | 0.71503    | 0.71503    | 0.71503    |   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:        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:      946928.0 ave      946928 max      946928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946928
Ave neighs/atom = 236.73200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.998219482321, Press = 1.583107786186
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   -12987.538   -12987.538   -13115.972   -13115.972    248.46421    248.46421    67854.331    67854.331    345.09085    345.09085 
   15000   -12982.896   -12982.896   -13114.355   -13114.355    254.31612    254.31612     67843.36     67843.36    765.35808    765.35808 
Loop time of 126.462 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.683 ns/day, 35.128 hours/ns, 7.907 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.45     | 125.45     | 125.45     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2005     | 0.2005     | 0.2005     |   0.0 |  0.16
Output  | 0.00017911 | 0.00017911 | 0.00017911 |   0.0 |  0.00
Modify  | 0.71218    | 0.71218    | 0.71218    |   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:        8237.00 ave        8237 max        8237 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:      946404.0 ave      946404 max      946404 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946404
Ave neighs/atom = 236.60100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.847254141411, Press = 3.07762619432382
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   -12982.896   -12982.896   -13114.355   -13114.355    254.31612    254.31612     67843.36     67843.36    765.35808    765.35808 
   16000   -12986.605   -12986.605    -13113.44    -13113.44    245.37089    245.37089    67726.786    67726.786    2471.0806    2471.0806 
Loop time of 126.342 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.684 ns/day, 35.095 hours/ns, 7.915 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.32     | 125.32     | 125.32     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20157    | 0.20157    | 0.20157    |   0.0 |  0.16
Output  | 0.0002745  | 0.0002745  | 0.0002745  |   0.0 |  0.00
Modify  | 0.71626    | 0.71626    | 0.71626    |   0.0 |  0.57
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:        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:      946940.0 ave      946940 max      946940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946940
Ave neighs/atom = 236.73500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.823821905276, Press = 4.02731907166482
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   -12986.605   -12986.605    -13113.44    -13113.44    245.37089    245.37089    67726.786    67726.786    2471.0806    2471.0806 
   17000   -12981.013   -12981.013   -13113.498   -13113.498    256.30093    256.30093     67850.29     67850.29    863.09236    863.09236 
Loop time of 128.507 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.672 ns/day, 35.696 hours/ns, 7.782 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.47     | 127.47     | 127.47     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20408    | 0.20408    | 0.20408    |   0.0 |  0.16
Output  | 0.0002943  | 0.0002943  | 0.0002943  |   0.0 |  0.00
Modify  | 0.73055    | 0.73055    | 0.73055    |   0.0 |  0.57
Other   |            | 0.1044     |            |       |  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:      948468.0 ave      948468 max      948468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 948468
Ave neighs/atom = 237.11700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.823501682729, Press = 1.58083152908444
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   -12981.013   -12981.013   -13113.498   -13113.498    256.30093    256.30093     67850.29     67850.29    863.09236    863.09236 
   18000   -12984.448   -12984.448   -13113.556   -13113.556    249.76913    249.76913    67860.623    67860.623    684.76923    684.76923 
Loop time of 129.714 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.666 ns/day, 36.032 hours/ns, 7.709 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.68     | 128.68     | 128.68     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20314    | 0.20314    | 0.20314    |   0.0 |  0.16
Output  | 0.00018214 | 0.00018214 | 0.00018214 |   0.0 |  0.00
Modify  | 0.72413    | 0.72413    | 0.72413    |   0.0 |  0.56
Other   |            | 0.1045     |            |       |  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:      946612.0 ave      946612 max      946612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946612
Ave neighs/atom = 236.65300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.933345405947, Press = 1.45754198530597
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   -12984.448   -12984.448   -13113.556   -13113.556    249.76913    249.76913    67860.623    67860.623    684.76923    684.76923 
   19000    -12981.43    -12981.43   -13113.278   -13113.278    255.06791    255.06791    67875.583    67875.583     473.4858     473.4858 
Loop time of 131.947 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.655 ns/day, 36.652 hours/ns, 7.579 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.91     | 130.91     | 130.91     |   0.0 | 99.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2058     | 0.2058     | 0.2058     |   0.0 |  0.16
Output  | 0.00021692 | 0.00021692 | 0.00021692 |   0.0 |  0.00
Modify  | 0.7316     | 0.7316     | 0.7316     |   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:        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:      946164.0 ave      946164 max      946164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946164
Ave neighs/atom = 236.54100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.971468411236, Press = 0.891312556869882
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    -12981.43    -12981.43   -13113.278   -13113.278    255.06791    255.06791    67875.583    67875.583     473.4858     473.4858 
   20000   -12985.409   -12985.409   -13115.968   -13115.968     252.5747     252.5747    67940.978    67940.978   -971.94052   -971.94052 
Loop time of 131.078 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.659 ns/day, 36.411 hours/ns, 7.629 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.03     | 130.03     | 130.03     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20578    | 0.20578    | 0.20578    |   0.0 |  0.16
Output  | 0.00017812 | 0.00017812 | 0.00017812 |   0.0 |  0.00
Modify  | 0.7352     | 0.7352     | 0.7352     |   0.0 |  0.56
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:        8253.00 ave        8253 max        8253 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:      946206.0 ave      946206 max      946206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946206
Ave neighs/atom = 236.55150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.872859741739, Press = 0.141927143209682
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   -12985.409   -12985.409   -13115.968   -13115.968     252.5747     252.5747    67940.978    67940.978   -971.94052   -971.94052 
   21000   -12981.452   -12981.452    -13114.34    -13114.34    257.08174    257.08174    68033.448    68033.448   -2014.4831   -2014.4831 
Loop time of 123.767 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.698 ns/day, 34.380 hours/ns, 8.080 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.76     | 122.76     | 122.76     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20061    | 0.20061    | 0.20061    |   0.0 |  0.16
Output  | 0.00017726 | 0.00017726 | 0.00017726 |   0.0 |  0.00
Modify  | 0.70466    | 0.70466    | 0.70466    |   0.0 |  0.57
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:        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:      945222.0 ave      945222 max      945222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945222
Ave neighs/atom = 236.30550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.914156082591, Press = -0.630555006622531
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   -12981.452   -12981.452    -13114.34    -13114.34    257.08174    257.08174    68033.448    68033.448   -2014.4831   -2014.4831 
   22000   -12988.064   -12988.064   -13116.673   -13116.673    248.80329    248.80329    67939.709    67939.709   -1018.0436   -1018.0436 
Loop time of 127.929 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.675 ns/day, 35.536 hours/ns, 7.817 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.9      | 126.9      | 126.9      |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20371    | 0.20371    | 0.20371    |   0.0 |  0.16
Output  | 0.00017762 | 0.00017762 | 0.00017762 |   0.0 |  0.00
Modify  | 0.72687    | 0.72687    | 0.72687    |   0.0 |  0.57
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:        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:      943772.0 ave      943772 max      943772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 943772
Ave neighs/atom = 235.94300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.879966442654, Press = 1.17060253015891
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   -12988.064   -12988.064   -13116.673   -13116.673    248.80329    248.80329    67939.709    67939.709   -1018.0436   -1018.0436 
   23000   -12982.625   -12982.625   -13114.643   -13114.643    255.39762    255.39762    67917.773    67917.773   -291.82308   -291.82308 
Loop time of 127.1 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.680 ns/day, 35.306 hours/ns, 7.868 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.07     | 126.07     | 126.07     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20393    | 0.20393    | 0.20393    |   0.0 |  0.16
Output  | 0.00017808 | 0.00017808 | 0.00017808 |   0.0 |  0.00
Modify  | 0.72421    | 0.72421    | 0.72421    |   0.0 |  0.57
Other   |            | 0.1035     |            |       |  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:      945132.0 ave      945132 max      945132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945132
Ave neighs/atom = 236.28300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.807084797743, Press = 1.40612547265934
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   -12982.625   -12982.625   -13114.643   -13114.643    255.39762    255.39762    67917.773    67917.773   -291.82308   -291.82308 
   24000   -12987.401   -12987.401    -13116.13    -13116.13    249.03582    249.03582    67924.724    67924.724   -668.71065   -668.71065 
Loop time of 130.682 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.661 ns/day, 36.301 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.64     | 129.64     | 129.64     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20508    | 0.20508    | 0.20508    |   0.0 |  0.16
Output  | 0.00017945 | 0.00017945 | 0.00017945 |   0.0 |  0.00
Modify  | 0.73131    | 0.73131    | 0.73131    |   0.0 |  0.56
Other   |            | 0.1046     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8252.00 ave        8252 max        8252 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:      945782.0 ave      945782 max      945782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945782
Ave neighs/atom = 236.44550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.757696840078, Press = 1.41657740940952
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   -12987.401   -12987.401    -13116.13    -13116.13    249.03582    249.03582    67924.724    67924.724   -668.71065   -668.71065 
   25000   -12982.104   -12982.104   -13113.043   -13113.043    253.31056    253.31056    67944.212    67944.212   -533.42979   -533.42979 
Loop time of 127.44 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.678 ns/day, 35.400 hours/ns, 7.847 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.42     | 126.42     | 126.42     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20344    | 0.20344    | 0.20344    |   0.0 |  0.16
Output  | 0.00017839 | 0.00017839 | 0.00017839 |   0.0 |  0.00
Modify  | 0.71827    | 0.71827    | 0.71827    |   0.0 |  0.56
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:        8224.00 ave        8224 max        8224 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:      945672.0 ave      945672 max      945672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945672
Ave neighs/atom = 236.41800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.74348307086, Press = 2.2939571481872
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   -12982.104   -12982.104   -13113.043   -13113.043    253.31056    253.31056    67944.212    67944.212   -533.42979   -533.42979 
   26000   -12990.318   -12990.318   -13119.218   -13119.218    249.36476    249.36476    67799.204    67799.204    701.49211    701.49211 
Loop time of 126.51 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.683 ns/day, 35.142 hours/ns, 7.905 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.49     | 125.49     | 125.49     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20353    | 0.20353    | 0.20353    |   0.0 |  0.16
Output  | 0.00017858 | 0.00017858 | 0.00017858 |   0.0 |  0.00
Modify  | 0.71734    | 0.71734    | 0.71734    |   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:        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:      945088.0 ave      945088 max      945088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945088
Ave neighs/atom = 236.27200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.69388758377, Press = 3.83207445866027
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   -12990.318   -12990.318   -13119.218   -13119.218    249.36476    249.36476    67799.204    67799.204    701.49211    701.49211 
   27000   -12982.578   -12982.578   -13112.883   -13112.883    252.08454    252.08454     67899.95     67899.95    38.319439    38.319439 
Loop time of 127.593 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.677 ns/day, 35.443 hours/ns, 7.837 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.56     | 126.56     | 126.56     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20365    | 0.20365    | 0.20365    |   0.0 |  0.16
Output  | 0.00017775 | 0.00017775 | 0.00017775 |   0.0 |  0.00
Modify  | 0.72599    | 0.72599    | 0.72599    |   0.0 |  0.57
Other   |            | 0.1042     |            |       |  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:      947310.0 ave      947310 max      947310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 947310
Ave neighs/atom = 236.82750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.681460184063, Press = 1.19197641276417
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   -12982.578   -12982.578   -13112.883   -13112.883    252.08454    252.08454     67899.95     67899.95    38.319439    38.319439 
   28000   -12984.349   -12984.349   -13113.406   -13113.406    249.66943    249.66943     67921.48     67921.48   -373.11087   -373.11087 
Loop time of 126.524 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.683 ns/day, 35.145 hours/ns, 7.904 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.5      | 125.5      | 125.5      |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20263    | 0.20263    | 0.20263    |   0.0 |  0.16
Output  | 0.00017833 | 0.00017833 | 0.00017833 |   0.0 |  0.00
Modify  | 0.71921    | 0.71921    | 0.71921    |   0.0 |  0.57
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:        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:      946054.0 ave      946054 max      946054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946054
Ave neighs/atom = 236.51350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.667515833996, Press = 1.54848058785184
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   -12984.349   -12984.349   -13113.406   -13113.406    249.66943    249.66943     67921.48     67921.48   -373.11087   -373.11087 
   29000   -12987.518   -12987.518   -13116.532   -13116.532    249.58613    249.58613    67877.917    67877.917   -72.125275   -72.125275 
Loop time of 122.594 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.705 ns/day, 34.054 hours/ns, 8.157 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.59     | 121.59     | 121.59     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19945    | 0.19945    | 0.19945    |   0.0 |  0.16
Output  | 0.00022684 | 0.00022684 | 0.00022684 |   0.0 |  0.00
Modify  | 0.70251    | 0.70251    | 0.70251    |   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:        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:      945590.0 ave      945590 max      945590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945590
Ave neighs/atom = 236.39750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.661594752632, Press = 1.66673785591747
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   -12987.518   -12987.518   -13116.532   -13116.532    249.58613    249.58613    67877.917    67877.917   -72.125275   -72.125275 
   30000   -12981.396   -12981.396   -13115.526   -13115.526    259.48406    259.48406    67879.173    67879.173    135.02148    135.02148 
Loop time of 123.916 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.697 ns/day, 34.421 hours/ns, 8.070 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.9      | 122.9      | 122.9      |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20197    | 0.20197    | 0.20197    |   0.0 |  0.16
Output  | 0.00054482 | 0.00054482 | 0.00054482 |   0.0 |  0.00
Modify  | 0.71349    | 0.71349    | 0.71349    |   0.0 |  0.58
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:        8253.00 ave        8253 max        8253 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:      946218.0 ave      946218 max      946218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946218
Ave neighs/atom = 236.55450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.631571156594, Press = 1.40496823419224
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   -12981.396   -12981.396   -13115.526   -13115.526    259.48406    259.48406    67879.173    67879.173    135.02148    135.02148 
   31000   -12984.052   -12984.052   -13113.469   -13113.469    250.36731    250.36731    67839.309    67839.309    1002.8004    1002.8004 
Loop time of 123.101 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.702 ns/day, 34.195 hours/ns, 8.123 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.09     | 122.09     | 122.09     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20133    | 0.20133    | 0.20133    |   0.0 |  0.16
Output  | 0.00017721 | 0.00017721 | 0.00017721 |   0.0 |  0.00
Modify  | 0.70817    | 0.70817    | 0.70817    |   0.0 |  0.58
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:        8227.00 ave        8227 max        8227 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:      945834.0 ave      945834 max      945834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945834
Ave neighs/atom = 236.45850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.605650248072, Press = 0.760161121891836
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   -12984.052   -12984.052   -13113.469   -13113.469    250.36731    250.36731    67839.309    67839.309    1002.8004    1002.8004 
   32000   -12981.954   -12981.954    -13113.07    -13113.07    253.65193    253.65193    67929.471    67929.471   -342.90656   -342.90656 
Loop time of 125.732 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.687 ns/day, 34.926 hours/ns, 7.953 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.71     | 124.71     | 124.71     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20392    | 0.20392    | 0.20392    |   0.0 |  0.16
Output  | 0.0001878  | 0.0001878  | 0.0001878  |   0.0 |  0.00
Modify  | 0.71738    | 0.71738    | 0.71738    |   0.0 |  0.57
Other   |            | 0.1047     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8255.00 ave        8255 max        8255 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:      946652.0 ave      946652 max      946652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946652
Ave neighs/atom = 236.66300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.578410691306, Press = 0.467575358435444
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   -12981.954   -12981.954    -13113.07    -13113.07    253.65193    253.65193    67929.471    67929.471   -342.90656   -342.90656 
   33000   -12988.378   -12988.378   -13116.487   -13116.487    247.83496    247.83496    67901.646    67901.646   -411.77625   -411.77625 
Loop time of 124.197 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.696 ns/day, 34.499 hours/ns, 8.052 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.18     | 123.18     | 123.18     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20285    | 0.20285    | 0.20285    |   0.0 |  0.16
Output  | 0.0001777  | 0.0001777  | 0.0001777  |   0.0 |  0.00
Modify  | 0.70899    | 0.70899    | 0.70899    |   0.0 |  0.57
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:        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:      945348.0 ave      945348 max      945348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945348
Ave neighs/atom = 236.33700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.579813954184, Press = 0.337347728405709
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   -12988.378   -12988.378   -13116.487   -13116.487    247.83496    247.83496    67901.646    67901.646   -411.77625   -411.77625 
   34000   -12982.805   -12982.805   -13113.291   -13113.291    252.43421    252.43421    67995.348    67995.348   -1372.2059   -1372.2059 
Loop time of 126.981 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.680 ns/day, 35.272 hours/ns, 7.875 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.96     | 125.96     | 125.96     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20252    | 0.20252    | 0.20252    |   0.0 |  0.16
Output  | 0.00017606 | 0.00017606 | 0.00017606 |   0.0 |  0.00
Modify  | 0.71732    | 0.71732    | 0.71732    |   0.0 |  0.56
Other   |            | 0.1036     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8226.00 ave        8226 max        8226 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:      945728.0 ave      945728 max      945728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945728
Ave neighs/atom = 236.43200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.562177077609, Press = -0.252077222549748
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   -12982.805   -12982.805   -13113.291   -13113.291    252.43421    252.43421    67995.348    67995.348   -1372.2059   -1372.2059 
   35000    -12984.55    -12984.55   -13113.567   -13113.567    249.59138    249.59138     67965.15     67965.15   -866.52321   -866.52321 
Loop time of 119.437 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.723 ns/day, 33.177 hours/ns, 8.373 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    | 118.45     | 118.45     | 118.45     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1949     | 0.1949     | 0.1949     |   0.0 |  0.16
Output  | 0.00023059 | 0.00023059 | 0.00023059 |   0.0 |  0.00
Modify  | 0.68521    | 0.68521    | 0.68521    |   0.0 |  0.57
Other   |            | 0.1021     |            |       |  0.09

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:      944450.0 ave      944450 max      944450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 944450
Ave neighs/atom = 236.11250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.589863114762, Press = 0.730060972480334
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    -12984.55    -12984.55   -13113.567   -13113.567    249.59138    249.59138     67965.15     67965.15   -866.52321   -866.52321 
   36000   -12978.366   -12978.366   -13114.077   -13114.077    262.54138    262.54138    67932.075    67932.075   -403.62314   -403.62314 
Loop time of 130.478 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.662 ns/day, 36.244 hours/ns, 7.664 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.43     | 129.43     | 129.43     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20579    | 0.20579    | 0.20579    |   0.0 |  0.16
Output  | 0.00022212 | 0.00022212 | 0.00022212 |   0.0 |  0.00
Modify  | 0.73488    | 0.73488    | 0.73488    |   0.0 |  0.56
Other   |            | 0.1044     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8271.00 ave        8271 max        8271 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:      944788.0 ave      944788 max      944788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 944788
Ave neighs/atom = 236.19700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.650297335021, Press = 1.34942602019625
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   -12978.366   -12978.366   -13114.077   -13114.077    262.54138    262.54138    67932.075    67932.075   -403.62314   -403.62314 
   37000   -12983.346   -12983.346   -13114.864   -13114.864    254.43043    254.43043    67851.383    67851.383    588.35155    588.35155 
Loop time of 124.019 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.697 ns/day, 34.450 hours/ns, 8.063 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        | 123        | 123        |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20278    | 0.20278    | 0.20278    |   0.0 |  0.16
Output  | 0.00017704 | 0.00017704 | 0.00017704 |   0.0 |  0.00
Modify  | 0.70845    | 0.70845    | 0.70845    |   0.0 |  0.57
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:        8232.00 ave        8232 max        8232 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:      945412.0 ave      945412 max      945412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945412
Ave neighs/atom = 236.35300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.676938078998, Press = 0.979905289443355
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   -12983.346   -12983.346   -13114.864   -13114.864    254.43043    254.43043    67851.383    67851.383    588.35155    588.35155 
   38000   -12984.813   -12984.813   -13116.213   -13116.213    254.20284    254.20284      67767.4      67767.4    1734.2422    1734.2422 
Loop time of 124.008 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.697 ns/day, 34.447 hours/ns, 8.064 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        | 123        | 123        |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20033    | 0.20033    | 0.20033    |   0.0 |  0.16
Output  | 0.00017458 | 0.00017458 | 0.00017458 |   0.0 |  0.00
Modify  | 0.70496    | 0.70496    | 0.70496    |   0.0 |  0.57
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:        8237.00 ave        8237 max        8237 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:      946620.0 ave      946620 max      946620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946620
Ave neighs/atom = 236.65500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.713496739768, Press = -0.221370859265158
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   -12984.813   -12984.813   -13116.213   -13116.213    254.20284    254.20284      67767.4      67767.4    1734.2422    1734.2422 
   39000   -12985.841   -12985.841   -13117.279   -13117.279    254.27489    254.27489    67826.832    67826.832    662.68617    662.68617 
Loop time of 125.746 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.687 ns/day, 34.930 hours/ns, 7.953 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.72     | 124.72     | 124.72     |   0.0 | 99.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20299    | 0.20299    | 0.20299    |   0.0 |  0.16
Output  | 0.0001784  | 0.0001784  | 0.0001784  |   0.0 |  0.00
Modify  | 0.71748    | 0.71748    | 0.71748    |   0.0 |  0.57
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:        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:      947798.0 ave      947798 max      947798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 947798
Ave neighs/atom = 236.94950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.71140760566, Press = -0.417553631837077
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   -12985.841   -12985.841   -13117.279   -13117.279    254.27489    254.27489    67826.832    67826.832    662.68617    662.68617 
   40000   -12982.184   -12982.184   -13114.463   -13114.463    255.90343    255.90343    67875.604    67875.604    346.21815    346.21815 
Loop time of 128.719 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.671 ns/day, 35.755 hours/ns, 7.769 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.69     | 127.69     | 127.69     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20423    | 0.20423    | 0.20423    |   0.0 |  0.16
Output  | 0.00017872 | 0.00017872 | 0.00017872 |   0.0 |  0.00
Modify  | 0.72352    | 0.72352    | 0.72352    |   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:        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:      946712.0 ave      946712 max      946712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946712
Ave neighs/atom = 236.67800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.736138510203, Press = -0.145149603227116
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   -12982.184   -12982.184   -13114.463   -13114.463    255.90343    255.90343    67875.604    67875.604    346.21815    346.21815 
   41000   -12981.865   -12981.865   -13112.974   -13112.974      253.639      253.639    67911.611    67911.611   -48.569313   -48.569313 
Loop time of 120.347 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.718 ns/day, 33.430 hours/ns, 8.309 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    | 119.35     | 119.35     | 119.35     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19915    | 0.19915    | 0.19915    |   0.0 |  0.17
Output  | 0.00017389 | 0.00017389 | 0.00017389 |   0.0 |  0.00
Modify  | 0.69332    | 0.69332    | 0.69332    |   0.0 |  0.58
Other   |            | 0.1032     |            |       |  0.09

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:      946130.0 ave      946130 max      946130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946130
Ave neighs/atom = 236.53250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.734727320423, Press = -0.164793213450225
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   -12981.865   -12981.865   -13112.974   -13112.974      253.639      253.639    67911.611    67911.611   -48.569313   -48.569313 
   42000    -12985.54    -12985.54   -13116.267   -13116.267    252.89995    252.89995    67899.268    67899.268   -241.66152   -241.66152 
Loop time of 121.374 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.712 ns/day, 33.715 hours/ns, 8.239 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    | 120.37     | 120.37     | 120.37     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19805    | 0.19805    | 0.19805    |   0.0 |  0.16
Output  | 0.0002275  | 0.0002275  | 0.0002275  |   0.0 |  0.00
Modify  | 0.69851    | 0.69851    | 0.69851    |   0.0 |  0.58
Other   |            | 0.1034     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8237.00 ave        8237 max        8237 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:      945776.0 ave      945776 max      945776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945776
Ave neighs/atom = 236.44400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.761960373954, Press = -0.225645439995086
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    -12985.54    -12985.54   -13116.267   -13116.267    252.89995    252.89995    67899.268    67899.268   -241.66152   -241.66152 
   43000   -12981.647   -12981.647   -13112.151   -13112.151    252.46845    252.46845    67920.409    67920.409   -157.69816   -157.69816 
Loop time of 122.219 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.707 ns/day, 33.950 hours/ns, 8.182 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.22     | 121.22     | 121.22     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19841    | 0.19841    | 0.19841    |   0.0 |  0.16
Output  | 0.0001784  | 0.0001784  | 0.0001784  |   0.0 |  0.00
Modify  | 0.69814    | 0.69814    | 0.69814    |   0.0 |  0.57
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:        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:      945810.0 ave      945810 max      945810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945810
Ave neighs/atom = 236.45250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.818553129867, Press = 0.52437664565535
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 
   43000   -12981.647   -12981.647   -13112.151   -13112.151    252.46845    252.46845    67920.409    67920.409   -157.69816   -157.69816 
   44000   -12982.392   -12982.392     -13113.5     -13113.5    253.63749    253.63749    67909.313    67909.313   -118.66564   -118.66564 
Loop time of 120.087 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.719 ns/day, 33.357 hours/ns, 8.327 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.1      | 119.1      | 119.1      |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19405    | 0.19405    | 0.19405    |   0.0 |  0.16
Output  | 0.00017686 | 0.00017686 | 0.00017686 |   0.0 |  0.00
Modify  | 0.69518    | 0.69518    | 0.69518    |   0.0 |  0.58
Other   |            | 0.1024     |            |       |  0.09

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:      945454.0 ave      945454 max      945454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945454
Ave neighs/atom = 236.36350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.845917917976, Press = 1.22226226284755
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 
   44000   -12982.392   -12982.392     -13113.5     -13113.5    253.63749    253.63749    67909.313    67909.313   -118.66564   -118.66564 
   45000   -12986.897   -12986.897   -13116.284   -13116.284    250.30816    250.30816    67859.834    67859.834     219.6335     219.6335 
Loop time of 117.727 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.734 ns/day, 32.702 hours/ns, 8.494 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    | 116.75     | 116.75     | 116.75     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19036    | 0.19036    | 0.19036    |   0.0 |  0.16
Output  | 0.00017845 | 0.00017845 | 0.00017845 |   0.0 |  0.00
Modify  | 0.68035    | 0.68035    | 0.68035    |   0.0 |  0.58
Other   |            | 0.1014     |            |       |  0.09

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:      945968.0 ave      945968 max      945968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945968
Ave neighs/atom = 236.49200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.868131500956, Press = 1.25292883472069
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 
   45000   -12986.897   -12986.897   -13116.284   -13116.284    250.30816    250.30816    67859.834    67859.834     219.6335     219.6335 
   46000   -12981.234   -12981.234    -13112.93    -13112.93    254.77558    254.77558    67929.672    67929.672   -398.00015   -398.00015 
Loop time of 120.436 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.717 ns/day, 33.454 hours/ns, 8.303 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    | 119.45     | 119.45     | 119.45     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19367    | 0.19367    | 0.19367    |   0.0 |  0.16
Output  | 0.00034122 | 0.00034122 | 0.00034122 |   0.0 |  0.00
Modify  | 0.69255    | 0.69255    | 0.69255    |   0.0 |  0.58
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:        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:      946530.0 ave      946530 max      946530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946530
Ave neighs/atom = 236.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 = 252.852403841, Press = 1.11350203085749
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 
   46000   -12981.234   -12981.234    -13112.93    -13112.93    254.77558    254.77558    67929.672    67929.672   -398.00015   -398.00015 
   47000   -12986.007   -12986.007   -13116.944   -13116.944    253.30673    253.30673    67920.246    67920.246   -719.16299   -719.16299 
Loop time of 117.143 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.738 ns/day, 32.540 hours/ns, 8.537 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    | 116.17     | 116.17     | 116.17     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19184    | 0.19184    | 0.19184    |   0.0 |  0.16
Output  | 0.00017957 | 0.00017957 | 0.00017957 |   0.0 |  0.00
Modify  | 0.68358    | 0.68358    | 0.68358    |   0.0 |  0.58
Other   |            | 0.102      |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8217.00 ave        8217 max        8217 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:      945228.0 ave      945228 max      945228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945228
Ave neighs/atom = 236.30700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.867477689837, Press = 0.797445476902969
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 
   47000   -12986.007   -12986.007   -13116.944   -13116.944    253.30673    253.30673    67920.246    67920.246   -719.16299   -719.16299 
   48000   -12982.893   -12982.893   -13114.411   -13114.411    254.43043    254.43043    67909.007    67909.007   -241.30858   -241.30858 
Loop time of 117.424 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.736 ns/day, 32.618 hours/ns, 8.516 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    | 116.45     | 116.45     | 116.45     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19124    | 0.19124    | 0.19124    |   0.0 |  0.16
Output  | 0.00017717 | 0.00017717 | 0.00017717 |   0.0 |  0.00
Modify  | 0.67971    | 0.67971    | 0.67971    |   0.0 |  0.58
Other   |            | 0.1023     |            |       |  0.09

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:      945662.0 ave      945662 max      945662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945662
Ave neighs/atom = 236.41550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.87893553284, Press = 1.52430758874249
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 
   48000   -12982.893   -12982.893   -13114.411   -13114.411    254.43043    254.43043    67909.007    67909.007   -241.30858   -241.30858 
   49000       -12985       -12985   -13115.727   -13115.727    252.90102    252.90102    67818.309    67818.309    1013.0585    1013.0585 
Loop time of 119.449 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.723 ns/day, 33.180 hours/ns, 8.372 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    | 118.47     | 118.47     | 118.47     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19254    | 0.19254    | 0.19254    |   0.0 |  0.16
Output  | 0.00018389 | 0.00018389 | 0.00018389 |   0.0 |  0.00
Modify  | 0.68918    | 0.68918    | 0.68918    |   0.0 |  0.58
Other   |            | 0.102      |            |       |  0.09

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:      945920.0 ave      945920 max      945920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945920
Ave neighs/atom = 236.48000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.89143397484, Press = 1.21559290877461
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 
   49000       -12985       -12985   -13115.727   -13115.727    252.90102    252.90102    67818.309    67818.309    1013.0585    1013.0585 
   50000     -12988.2     -12988.2   -13119.573   -13119.573    254.14943    254.14943    67882.894    67882.894   -340.53233   -340.53233 
Loop time of 119.575 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.723 ns/day, 33.215 hours/ns, 8.363 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    | 118.59     | 118.59     | 118.59     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19204    | 0.19204    | 0.19204    |   0.0 |  0.16
Output  | 0.00017496 | 0.00017496 | 0.00017496 |   0.0 |  0.00
Modify  | 0.68924    | 0.68924    | 0.68924    |   0.0 |  0.58
Other   |            | 0.1034     |            |       |  0.09

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:      946850.0 ave      946850 max      946850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946850
Ave neighs/atom = 236.71250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.882235521047, Press = 0.741728827123951
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 
   50000     -12988.2     -12988.2   -13119.573   -13119.573    254.14943    254.14943    67882.894    67882.894   -340.53233   -340.53233 
   51000   -12982.701   -12982.701   -13112.903   -13112.903    251.88352    251.88352    67929.519    67929.519   -278.06954   -278.06954 
Loop time of 119.046 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.726 ns/day, 33.068 hours/ns, 8.400 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    | 118.06     | 118.06     | 118.06     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1908     | 0.1908     | 0.1908     |   0.0 |  0.16
Output  | 0.00035528 | 0.00035528 | 0.00035528 |   0.0 |  0.00
Modify  | 0.68947    | 0.68947    | 0.68947    |   0.0 |  0.58
Other   |            | 0.1018     |            |       |  0.09

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:      946136.0 ave      946136 max      946136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946136
Ave neighs/atom = 236.53400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.862909078732, Press = 0.802110773975739
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 
   51000   -12982.701   -12982.701   -13112.903   -13112.903    251.88352    251.88352    67929.519    67929.519   -278.06954   -278.06954 
   52000   -12987.901   -12987.901   -13116.988   -13116.988    249.72753    249.72753    67880.003    67880.003   -176.40322   -176.40322 
Loop time of 116.316 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.743 ns/day, 32.310 hours/ns, 8.597 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    | 115.34     | 115.34     | 115.34     |   0.0 | 99.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.189      | 0.189      | 0.189      |   0.0 |  0.16
Output  | 0.00017956 | 0.00017956 | 0.00017956 |   0.0 |  0.00
Modify  | 0.68105    | 0.68105    | 0.68105    |   0.0 |  0.59
Other   |            | 0.1022     |            |       |  0.09

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:      945440.0 ave      945440 max      945440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945440
Ave neighs/atom = 236.36000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.836092922347, Press = 0.884341229206407
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 
   52000   -12987.901   -12987.901   -13116.988   -13116.988    249.72753    249.72753    67880.003    67880.003   -176.40322   -176.40322 
   53000   -12982.793   -12982.793   -13114.385   -13114.385    254.57217    254.57217     67862.96     67862.96    343.82346    343.82346 
Loop time of 116.708 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.740 ns/day, 32.419 hours/ns, 8.568 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    | 115.74     | 115.74     | 115.74     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19003    | 0.19003    | 0.19003    |   0.0 |  0.16
Output  | 0.00017646 | 0.00017646 | 0.00017646 |   0.0 |  0.00
Modify  | 0.67685    | 0.67685    | 0.67685    |   0.0 |  0.58
Other   |            | 0.1019     |            |       |  0.09

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:      946320.0 ave      946320 max      946320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946320
Ave neighs/atom = 236.58000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.83169853452, Press = 1.40388696157388
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 
   53000   -12982.793   -12982.793   -13114.385   -13114.385    254.57217    254.57217     67862.96     67862.96    343.82346    343.82346 
   54000   -12980.998   -12980.998   -13113.418   -13113.418    256.17522    256.17522    67836.464    67836.464    1068.3426    1068.3426 
Loop time of 116.617 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.741 ns/day, 32.394 hours/ns, 8.575 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.64     | 115.64     | 115.64     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19095    | 0.19095    | 0.19095    |   0.0 |  0.16
Output  | 0.00017585 | 0.00017585 | 0.00017585 |   0.0 |  0.00
Modify  | 0.67918    | 0.67918    | 0.67918    |   0.0 |  0.58
Other   |            | 0.1026     |            |       |  0.09

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:      946204.0 ave      946204 max      946204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946204
Ave neighs/atom = 236.55100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.849940459027, Press = 0.879385161922387
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 
   54000   -12980.998   -12980.998   -13113.418   -13113.418    256.17522    256.17522    67836.464    67836.464    1068.3426    1068.3426 
   55000   -12986.684   -12986.684     -13115.1     -13115.1    248.42955    248.42955    67839.287    67839.287    748.51093    748.51093 
Loop time of 118.347 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.730 ns/day, 32.874 hours/ns, 8.450 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    | 117.37     | 117.37     | 117.37     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19159    | 0.19159    | 0.19159    |   0.0 |  0.16
Output  | 0.00017738 | 0.00017738 | 0.00017738 |   0.0 |  0.00
Modify  | 0.68432    | 0.68432    | 0.68432    |   0.0 |  0.58
Other   |            | 0.102      |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8252.00 ave        8252 max        8252 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:      946716.0 ave      946716 max      946716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946716
Ave neighs/atom = 236.67900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.849629267825, Press = 0.559672467961781
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 
   55000   -12986.684   -12986.684     -13115.1     -13115.1    248.42955    248.42955    67839.287    67839.287    748.51093    748.51093 
   56000   -12982.843   -12982.843   -13113.994   -13113.994    253.71994    253.71994     67877.13     67877.13    195.39601    195.39601 
Loop time of 117.409 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.736 ns/day, 32.613 hours/ns, 8.517 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    | 116.44     | 116.44     | 116.44     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1922     | 0.1922     | 0.1922     |   0.0 |  0.16
Output  | 0.00017904 | 0.00017904 | 0.00017904 |   0.0 |  0.00
Modify  | 0.6776     | 0.6776     | 0.6776     |   0.0 |  0.58
Other   |            | 0.1015     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8271.00 ave        8271 max        8271 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:      946702.0 ave      946702 max      946702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946702
Ave neighs/atom = 236.67550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.841551040518, Press = 0.607757721493519
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 
   56000   -12982.843   -12982.843   -13113.994   -13113.994    253.71994    253.71994     67877.13     67877.13    195.39601    195.39601 
   57000   -12986.236   -12986.236   -13117.199   -13117.199    253.35601    253.35601    67909.529    67909.529   -569.45784   -569.45784 
Loop time of 117.102 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.738 ns/day, 32.528 hours/ns, 8.540 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    | 116.13     | 116.13     | 116.13     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19005    | 0.19005    | 0.19005    |   0.0 |  0.16
Output  | 0.00017679 | 0.00017679 | 0.00017679 |   0.0 |  0.00
Modify  | 0.68134    | 0.68134    | 0.68134    |   0.0 |  0.58
Other   |            | 0.1024     |            |       |  0.09

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:      946112.0 ave      946112 max      946112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946112
Ave neighs/atom = 236.52800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.842280111115, Press = 0.440979715612606
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 
   57000   -12986.236   -12986.236   -13117.199   -13117.199    253.35601    253.35601    67909.529    67909.529   -569.45784   -569.45784 
   58000   -12983.999   -12983.999   -13115.336   -13115.336    254.07953    254.07953    67924.218    67924.218   -541.50148   -541.50148 
Loop time of 117.192 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.737 ns/day, 32.553 hours/ns, 8.533 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    | 116.22     | 116.22     | 116.22     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19073    | 0.19073    | 0.19073    |   0.0 |  0.16
Output  | 0.00017818 | 0.00017818 | 0.00017818 |   0.0 |  0.00
Modify  | 0.68166    | 0.68166    | 0.68166    |   0.0 |  0.58
Other   |            | 0.1022     |            |       |  0.09

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:      945698.0 ave      945698 max      945698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945698
Ave neighs/atom = 236.42450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.870286736616, Press = 0.334138047997437
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 
   58000   -12983.999   -12983.999   -13115.336   -13115.336    254.07953    254.07953    67924.218    67924.218   -541.50148   -541.50148 
   59000   -12980.588   -12980.588   -13110.821   -13110.821     251.9457     251.9457    67913.926    67913.926    292.08192    292.08192 
Loop time of 121.243 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.713 ns/day, 33.679 hours/ns, 8.248 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    | 120.25     | 120.25     | 120.25     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19557    | 0.19557    | 0.19557    |   0.0 |  0.16
Output  | 0.0001775  | 0.0001775  | 0.0001775  |   0.0 |  0.00
Modify  | 0.69878    | 0.69878    | 0.69878    |   0.0 |  0.58
Other   |            | 0.1031     |            |       |  0.09

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:      945568.0 ave      945568 max      945568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945568
Ave neighs/atom = 236.39200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.879628679553, Press = 0.50913191575791
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 
   59000   -12980.588   -12980.588   -13110.821   -13110.821     251.9457     251.9457    67913.926    67913.926    292.08192    292.08192 
   60000   -12984.865   -12984.865   -13114.155   -13114.155    250.11999    250.11999    67915.421    67915.421   -350.03333   -350.03333 
Loop time of 115.301 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.749 ns/day, 32.028 hours/ns, 8.673 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    | 114.34     | 114.34     | 114.34     |   0.0 | 99.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18968    | 0.18968    | 0.18968    |   0.0 |  0.16
Output  | 0.00023927 | 0.00023927 | 0.00023927 |   0.0 |  0.00
Modify  | 0.67136    | 0.67136    | 0.67136    |   0.0 |  0.58
Other   |            | 0.1015     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8245.00 ave        8245 max        8245 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:      945854.0 ave      945854 max      945854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945854
Ave neighs/atom = 236.46350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.918782138116, Press = -0.0387480560802468
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 
   60000   -12984.865   -12984.865   -13114.155   -13114.155    250.11999    250.11999    67915.421    67915.421   -350.03333   -350.03333 
   61000   -12979.673   -12979.673   -13113.662   -13113.662    259.20964    259.20964    67943.929    67943.929    -579.8171    -579.8171 
Loop time of 116.016 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.745 ns/day, 32.227 hours/ns, 8.620 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    | 115.05     | 115.05     | 115.05     |   0.0 | 99.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19006    | 0.19006    | 0.19006    |   0.0 |  0.16
Output  | 0.00017816 | 0.00017816 | 0.00017816 |   0.0 |  0.00
Modify  | 0.6776     | 0.6776     | 0.6776     |   0.0 |  0.58
Other   |            | 0.1014     |            |       |  0.09

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:      945780.0 ave      945780 max      945780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945780
Ave neighs/atom = 236.44500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.93884510346, Press = 0.0568882164299903
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 
   61000   -12979.673   -12979.673   -13113.662   -13113.662    259.20964    259.20964    67943.929    67943.929    -579.8171    -579.8171 
   62000   -12984.028   -12984.028    -13114.05    -13114.05    251.53634    251.53634    67999.739    67999.739   -1479.0788   -1479.0788 
Loop time of 118.777 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.727 ns/day, 32.993 hours/ns, 8.419 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    | 117.79     | 117.79     | 117.79     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19215    | 0.19215    | 0.19215    |   0.0 |  0.16
Output  | 0.00023026 | 0.00023026 | 0.00023026 |   0.0 |  0.00
Modify  | 0.68659    | 0.68659    | 0.68659    |   0.0 |  0.58
Other   |            | 0.1029     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8258.00 ave        8258 max        8258 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:      945250.0 ave      945250 max      945250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945250
Ave neighs/atom = 236.31250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.936922977916, Press = 0.151259850620581
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 
   62000   -12984.028   -12984.028    -13114.05    -13114.05    251.53634    251.53634    67999.739    67999.739   -1479.0788   -1479.0788 
   63000   -12989.425   -12989.425   -13116.553   -13116.553    245.93738    245.93738    67933.509    67933.509   -907.58611   -907.58611 
Loop time of 116.708 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.740 ns/day, 32.419 hours/ns, 8.568 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    | 115.74     | 115.74     | 115.74     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19008    | 0.19008    | 0.19008    |   0.0 |  0.16
Output  | 0.00017721 | 0.00017721 | 0.00017721 |   0.0 |  0.00
Modify  | 0.67751    | 0.67751    | 0.67751    |   0.0 |  0.58
Other   |            | 0.102      |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8231.00 ave        8231 max        8231 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:      944314.0 ave      944314 max      944314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 944314
Ave neighs/atom = 236.07850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.928416499454, Press = 0.795805644653679
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 
   63000   -12989.425   -12989.425   -13116.553   -13116.553    245.93738    245.93738    67933.509    67933.509   -907.58611   -907.58611 
   64000   -12982.574   -12982.574   -13112.087   -13112.087    250.55263    250.55263    67919.578    67919.578   -2.2630041   -2.2630041 
Loop time of 119.22 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.725 ns/day, 33.117 hours/ns, 8.388 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    | 118.23     | 118.23     | 118.23     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19465    | 0.19465    | 0.19465    |   0.0 |  0.16
Output  | 0.00017307 | 0.00017307 | 0.00017307 |   0.0 |  0.00
Modify  | 0.69281    | 0.69281    | 0.69281    |   0.0 |  0.58
Other   |            | 0.1029     |            |       |  0.09

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:      945332.0 ave      945332 max      945332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945332
Ave neighs/atom = 236.33300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.905387612766, Press = 0.809970606073497
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 
   64000   -12982.574   -12982.574   -13112.087   -13112.087    250.55263    250.55263    67919.578    67919.578   -2.2630041   -2.2630041 
   65000   -12987.623   -12987.623   -13117.148   -13117.148     250.5747     250.5747    67874.756    67874.756   -179.41122   -179.41122 
Loop time of 116.144 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.744 ns/day, 32.262 hours/ns, 8.610 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    | 115.18     | 115.18     | 115.18     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18935    | 0.18935    | 0.18935    |   0.0 |  0.16
Output  | 0.00017682 | 0.00017682 | 0.00017682 |   0.0 |  0.00
Modify  | 0.67563    | 0.67563    | 0.67563    |   0.0 |  0.58
Other   |            | 0.1026     |            |       |  0.09

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:      945544.0 ave      945544 max      945544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945544
Ave neighs/atom = 236.38600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.892993536375, Press = 0.331016099108199
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 
   65000   -12987.623   -12987.623   -13117.148   -13117.148     250.5747     250.5747    67874.756    67874.756   -179.41122   -179.41122 
   66000   -12983.075   -12983.075    -13114.61    -13114.61    254.46264    254.46264    67904.717    67904.717    -177.9616    -177.9616 
Loop time of 117.329 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.736 ns/day, 32.591 hours/ns, 8.523 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    | 116.36     | 116.36     | 116.36     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19041    | 0.19041    | 0.19041    |   0.0 |  0.16
Output  | 0.00023    | 0.00023    | 0.00023    |   0.0 |  0.00
Modify  | 0.67876    | 0.67876    | 0.67876    |   0.0 |  0.58
Other   |            | 0.1021     |            |       |  0.09

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:      946370.0 ave      946370 max      946370 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946370
Ave neighs/atom = 236.59250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.885432327171, Press = 0.446957314288073
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 
   66000   -12983.075   -12983.075    -13114.61    -13114.61    254.46264    254.46264    67904.717    67904.717    -177.9616    -177.9616 
   67000    -12983.44    -12983.44   -13113.886   -13113.886     252.3567     252.3567    67894.173    67894.173   -10.608669   -10.608669 
Loop time of 119.721 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.722 ns/day, 33.256 hours/ns, 8.353 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    | 118.73     | 118.73     | 118.73     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19249    | 0.19249    | 0.19249    |   0.0 |  0.16
Output  | 0.00017743 | 0.00017743 | 0.00017743 |   0.0 |  0.00
Modify  | 0.69508    | 0.69508    | 0.69508    |   0.0 |  0.58
Other   |            | 0.1034     |            |       |  0.09

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:      945646.0 ave      945646 max      945646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945646
Ave neighs/atom = 236.41150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.901184349534, Press = 0.0414094822328877
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 
   67000    -12983.44    -12983.44   -13113.886   -13113.886     252.3567     252.3567    67894.173    67894.173   -10.608669   -10.608669 
   68000   -12984.809   -12984.809   -13113.133   -13113.133    248.25093    248.25093    67878.488    67878.488    392.17013    392.17013 
Loop time of 117.517 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.735 ns/day, 32.643 hours/ns, 8.509 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    | 116.54     | 116.54     | 116.54     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19076    | 0.19076    | 0.19076    |   0.0 |  0.16
Output  | 0.00017727 | 0.00017727 | 0.00017727 |   0.0 |  0.00
Modify  | 0.68065    | 0.68065    | 0.68065    |   0.0 |  0.58
Other   |            | 0.1017     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8253.00 ave        8253 max        8253 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:      945952.0 ave      945952 max      945952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945952
Ave neighs/atom = 236.48800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.899442529982, Press = -0.346170783264369
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 
   68000   -12984.809   -12984.809   -13113.133   -13113.133    248.25093    248.25093    67878.488    67878.488    392.17013    392.17013 
   69000   -12984.416   -12984.416   -13112.753   -13112.753    248.27606    248.27606    67874.101    67874.101     441.6704     441.6704 
Loop time of 119.343 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.724 ns/day, 33.151 hours/ns, 8.379 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    | 118.35     | 118.35     | 118.35     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19345    | 0.19345    | 0.19345    |   0.0 |  0.16
Output  | 0.00022783 | 0.00022783 | 0.00022783 |   0.0 |  0.00
Modify  | 0.69503    | 0.69503    | 0.69503    |   0.0 |  0.58
Other   |            | 0.1032     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8268.00 ave        8268 max        8268 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:      946152.0 ave      946152 max      946152 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946152
Ave neighs/atom = 236.53800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.904664803066, Press = -0.16886697650017
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 
   69000   -12984.416   -12984.416   -13112.753   -13112.753    248.27606    248.27606    67874.101    67874.101     441.6704     441.6704 
   70000   -12985.453   -12985.453   -13115.011   -13115.011    250.63934    250.63934     67828.51     67828.51    1005.2842    1005.2842 
Loop time of 119.394 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.724 ns/day, 33.165 hours/ns, 8.376 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    | 118.41     | 118.41     | 118.41     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19339    | 0.19339    | 0.19339    |   0.0 |  0.16
Output  | 0.00017554 | 0.00017554 | 0.00017554 |   0.0 |  0.00
Modify  | 0.69011    | 0.69011    | 0.69011    |   0.0 |  0.58
Other   |            | 0.1013     |            |       |  0.08

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8258.00 ave        8258 max        8258 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:      946142.0 ave      946142 max      946142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946142
Ave neighs/atom = 236.53550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.887274133121, Press = 0.260817039976418
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 
   70000   -12985.453   -12985.453   -13115.011   -13115.011    250.63934    250.63934     67828.51     67828.51    1005.2842    1005.2842 
   71000    -12981.34    -12981.34   -13113.469   -13113.469    255.61097    255.61097    67840.419    67840.419    978.44961    978.44961 
Loop time of 120.57 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.717 ns/day, 33.492 hours/ns, 8.294 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    | 119.58     | 119.58     | 119.58     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19272    | 0.19272    | 0.19272    |   0.0 |  0.16
Output  | 0.00046985 | 0.00046985 | 0.00046985 |   0.0 |  0.00
Modify  | 0.69205    | 0.69205    | 0.69205    |   0.0 |  0.57
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:        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:      946944.0 ave      946944 max      946944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946944
Ave neighs/atom = 236.73600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.900073389125, Press = 0.138451994467131
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 
   71000    -12981.34    -12981.34   -13113.469   -13113.469    255.61097    255.61097    67840.419    67840.419    978.44961    978.44961 
   72000   -12981.683   -12981.683   -13113.659   -13113.659    255.31748    255.31748    67907.082    67907.082   -48.536115   -48.536115 
Loop time of 116.078 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.744 ns/day, 32.244 hours/ns, 8.615 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    | 115.11     | 115.11     | 115.11     |   0.0 | 99.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19157    | 0.19157    | 0.19157    |   0.0 |  0.17
Output  | 0.00017633 | 0.00017633 | 0.00017633 |   0.0 |  0.00
Modify  | 0.6768     | 0.6768     | 0.6768     |   0.0 |  0.58
Other   |            | 0.1025     |            |       |  0.09

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:      946688.0 ave      946688 max      946688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946688
Ave neighs/atom = 236.67200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.910532382079, Press = 0.0681543003811024
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 
   72000   -12981.683   -12981.683   -13113.659   -13113.659    255.31748    255.31748    67907.082    67907.082   -48.536115   -48.536115 
   73000   -12985.159   -12985.159   -13113.877   -13113.877    249.01518    249.01518    67857.649    67857.649    573.71751    573.71751 
Loop time of 123.553 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.699 ns/day, 34.320 hours/ns, 8.094 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.55     | 122.55     | 122.55     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19569    | 0.19569    | 0.19569    |   0.0 |  0.16
Output  | 0.00022543 | 0.00022543 | 0.00022543 |   0.0 |  0.00
Modify  | 0.70855    | 0.70855    | 0.70855    |   0.0 |  0.57
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:        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:      945710.0 ave      945710 max      945710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945710
Ave neighs/atom = 236.42750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.937507638472, Press = 0.188036840272284
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 
   73000   -12985.159   -12985.159   -13113.877   -13113.877    249.01518    249.01518    67857.649    67857.649    573.71751    573.71751 
   74000   -12981.147   -12981.147   -13112.536   -13112.536    254.18016    254.18016     67912.04     67912.04   -32.395719   -32.395719 
Loop time of 119.79 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.721 ns/day, 33.275 hours/ns, 8.348 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 118.81     | 118.81     | 118.81     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19249    | 0.19249    | 0.19249    |   0.0 |  0.16
Output  | 0.00017403 | 0.00017403 | 0.00017403 |   0.0 |  0.00
Modify  | 0.68982    | 0.68982    | 0.68982    |   0.0 |  0.58
Other   |            | 0.1019     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8232.00 ave        8232 max        8232 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:      946508.0 ave      946508 max      946508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946508
Ave neighs/atom = 236.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 = 252.940490433861, Press = 0.373531670433249
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 
   74000   -12981.147   -12981.147   -13112.536   -13112.536    254.18016    254.18016     67912.04     67912.04   -32.395719   -32.395719 
   75000   -12985.113   -12985.113    -13116.02    -13116.02    253.24725    253.24725    67919.335    67919.335   -430.74791   -430.74791 
Loop time of 124.213 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.696 ns/day, 34.504 hours/ns, 8.051 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.19     | 123.19     | 123.19     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19828    | 0.19828    | 0.19828    |   0.0 |  0.16
Output  | 0.0001755  | 0.0001755  | 0.0001755  |   0.0 |  0.00
Modify  | 0.71812    | 0.71812    | 0.71812    |   0.0 |  0.58
Other   |            | 0.1036     |            |       |  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:      945738.0 ave      945738 max      945738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945738
Ave neighs/atom = 236.43450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.937798877553, Press = 0.133413690968603
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 
   75000   -12985.113   -12985.113    -13116.02    -13116.02    253.24725    253.24725    67919.335    67919.335   -430.74791   -430.74791 
   76000    -12983.34    -12983.34   -13112.722   -13112.722    250.29853    250.29853    68009.931    68009.931   -1533.2327   -1533.2327 
Loop time of 119.119 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.725 ns/day, 33.089 hours/ns, 8.395 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    | 118.13     | 118.13     | 118.13     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19236    | 0.19236    | 0.19236    |   0.0 |  0.16
Output  | 0.00017141 | 0.00017141 | 0.00017141 |   0.0 |  0.00
Modify  | 0.69582    | 0.69582    | 0.69582    |   0.0 |  0.58
Other   |            | 0.1033     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8253.00 ave        8253 max        8253 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:      945518.0 ave      945518 max      945518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945518
Ave neighs/atom = 236.37950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.930998472199, Press = 0.0600671006247979
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 
   76000    -12983.34    -12983.34   -13112.722   -13112.722    250.29853    250.29853    68009.931    68009.931   -1533.2327   -1533.2327 
   77000   -12989.928   -12989.928   -13115.005   -13115.005      241.969      241.969    67958.983    67958.983   -1079.7554   -1079.7554 
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.94     | 120.94     | 120.94     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19295    | 0.19295    | 0.19295    |   0.0 |  0.16
Output  | 0.00017923 | 0.00017923 | 0.00017923 |   0.0 |  0.00
Modify  | 0.70528    | 0.70528    | 0.70528    |   0.0 |  0.58
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:        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:      944340.0 ave      944340 max      944340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 944340
Ave neighs/atom = 236.08500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.917002668034, Press = 0.624478255856815
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 
   77000   -12989.928   -12989.928   -13115.005   -13115.005      241.969      241.969    67958.983    67958.983   -1079.7554   -1079.7554 
   78000   -12981.354   -12981.354   -13112.015   -13112.015    252.77416    252.77416    67929.053    67929.053   -275.92944   -275.92944 
Loop time of 121.368 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.712 ns/day, 33.713 hours/ns, 8.239 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.37     | 120.37     | 120.37     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19507    | 0.19507    | 0.19507    |   0.0 |  0.16
Output  | 0.00018018 | 0.00018018 | 0.00018018 |   0.0 |  0.00
Modify  | 0.70083    | 0.70083    | 0.70083    |   0.0 |  0.58
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:        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:      944820.0 ave      944820 max      944820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 944820
Ave neighs/atom = 236.20500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.908596380225, Press = 0.691424580286968
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 
   78000   -12981.354   -12981.354   -13112.015   -13112.015    252.77416    252.77416    67929.053    67929.053   -275.92944   -275.92944 
   79000   -12983.246   -12983.246   -13113.074   -13113.074    251.16154    251.16154    67949.213    67949.213   -736.95251   -736.95251 
Loop time of 120.729 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.716 ns/day, 33.536 hours/ns, 8.283 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    | 119.73     | 119.73     | 119.73     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19532    | 0.19532    | 0.19532    |   0.0 |  0.16
Output  | 0.00017826 | 0.00017826 | 0.00017826 |   0.0 |  0.00
Modify  | 0.70268    | 0.70268    | 0.70268    |   0.0 |  0.58
Other   |            | 0.1022     |            |       |  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:      945336.0 ave      945336 max      945336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945336
Ave neighs/atom = 236.33400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.911383877548, Press = 0.411381656287339
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 
   79000   -12983.246   -12983.246   -13113.074   -13113.074    251.16154    251.16154    67949.213    67949.213   -736.95251   -736.95251 
   80000   -12986.503   -12986.503   -13116.485   -13116.485    251.45826    251.45826    67938.282    67938.282   -950.53797   -950.53797 
Loop time of 118.246 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.731 ns/day, 32.846 hours/ns, 8.457 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    | 117.26     | 117.26     | 117.26     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.192      | 0.192      | 0.192      |   0.0 |  0.16
Output  | 0.0001779  | 0.0001779  | 0.0001779  |   0.0 |  0.00
Modify  | 0.69002    | 0.69002    | 0.69002    |   0.0 |  0.58
Other   |            | 0.1026     |            |       |  0.09

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:      944946.0 ave      944946 max      944946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 944946
Ave neighs/atom = 236.23650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.931397750292, Press = 0.19468496314313
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 
   80000   -12986.503   -12986.503   -13116.485   -13116.485    251.45826    251.45826    67938.282    67938.282   -950.53797   -950.53797 
   81000   -12983.391   -12983.391   -13114.264   -13114.264    253.18414    253.18414    67939.225    67939.225   -678.58406   -678.58406 
Loop time of 123.813 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.698 ns/day, 34.393 hours/ns, 8.077 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    | 122.8      | 122.8      | 122.8      |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19687    | 0.19687    | 0.19687    |   0.0 |  0.16
Output  | 0.00017918 | 0.00017918 | 0.00017918 |   0.0 |  0.00
Modify  | 0.71289    | 0.71289    | 0.71289    |   0.0 |  0.58
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:        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:      945464.0 ave      945464 max      945464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945464
Ave neighs/atom = 236.36600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.933596878473, Press = 0.473171656441311
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 
   81000   -12983.391   -12983.391   -13114.264   -13114.264    253.18414    253.18414    67939.225    67939.225   -678.58406   -678.58406 
   82000   -12988.398   -12988.398   -13115.529   -13115.529    245.94198    245.94198    67906.362    67906.362   -418.71426   -418.71426 
Loop time of 116.846 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.739 ns/day, 32.457 hours/ns, 8.558 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    | 115.87     | 115.87     | 115.87     |   0.0 | 99.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19199    | 0.19199    | 0.19199    |   0.0 |  0.16
Output  | 0.00017588 | 0.00017588 | 0.00017588 |   0.0 |  0.00
Modify  | 0.68144    | 0.68144    | 0.68144    |   0.0 |  0.58
Other   |            | 0.1028     |            |       |  0.09

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:      945456.0 ave      945456 max      945456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945456
Ave neighs/atom = 236.36400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.932327330892, Press = 0.411269690982115
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 
   82000   -12988.398   -12988.398   -13115.529   -13115.529    245.94198    245.94198    67906.362    67906.362   -418.71426   -418.71426 
   83000   -12982.787   -12982.787   -13113.102   -13113.102    252.10427    252.10427    67880.097    67880.097    402.72298    402.72298 
Loop time of 123.466 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.700 ns/day, 34.296 hours/ns, 8.099 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.46     | 122.46     | 122.46     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19752    | 0.19752    | 0.19752    |   0.0 |  0.16
Output  | 0.00022969 | 0.00022969 | 0.00022969 |   0.0 |  0.00
Modify  | 0.70959    | 0.70959    | 0.70959    |   0.0 |  0.57
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:        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:      945810.0 ave      945810 max      945810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945810
Ave neighs/atom = 236.45250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.920714427226, Press = 0.492512048976927
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 
   83000   -12982.787   -12982.787   -13113.102   -13113.102    252.10427    252.10427    67880.097    67880.097    402.72298    402.72298 
   84000   -12987.115   -12987.115   -13115.393   -13115.393    248.16361    248.16361    67817.658    67817.658    723.50963    723.50963 
Loop time of 122.52 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.705 ns/day, 34.033 hours/ns, 8.162 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.52     | 121.52     | 121.52     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19625    | 0.19625    | 0.19625    |   0.0 |  0.16
Output  | 0.00017875 | 0.00017875 | 0.00017875 |   0.0 |  0.00
Modify  | 0.70026    | 0.70026    | 0.70026    |   0.0 |  0.57
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:        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:      946102.0 ave      946102 max      946102 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946102
Ave neighs/atom = 236.52550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.903544062318, Press = 0.644524823150654
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 
   84000   -12987.115   -12987.115   -13115.393   -13115.393    248.16361    248.16361    67817.658    67817.658    723.50963    723.50963 
   85000   -12980.438   -12980.438   -13112.849   -13112.849    256.15844    256.15844    67860.895    67860.895    588.92227    588.92227 
Loop time of 120.839 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.715 ns/day, 33.566 hours/ns, 8.275 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    | 119.85     | 119.85     | 119.85     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19458    | 0.19458    | 0.19458    |   0.0 |  0.16
Output  | 0.0001759  | 0.0001759  | 0.0001759  |   0.0 |  0.00
Modify  | 0.69621    | 0.69621    | 0.69621    |   0.0 |  0.58
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:        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:      946938.0 ave      946938 max      946938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946938
Ave neighs/atom = 236.73450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.90608441068, Press = 0.652971324656526
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 
   85000   -12980.438   -12980.438   -13112.849   -13112.849    256.15844    256.15844    67860.895    67860.895    588.92227    588.92227 
   86000   -12983.748   -12983.748   -13114.854   -13114.854    253.63287    253.63287    67814.153    67814.153    1046.9983    1046.9983 
Loop time of 119.833 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.721 ns/day, 33.287 hours/ns, 8.345 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    | 118.85     | 118.85     | 118.85     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19289    | 0.19289    | 0.19289    |   0.0 |  0.16
Output  | 0.00021885 | 0.00021885 | 0.00021885 |   0.0 |  0.00
Modify  | 0.68878    | 0.68878    | 0.68878    |   0.0 |  0.57
Other   |            | 0.1019     |            |       |  0.09

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:      946350.0 ave      946350 max      946350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946350
Ave neighs/atom = 236.58750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.928650787872, Press = 0.452050159917059
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 
   86000   -12983.748   -12983.748   -13114.854   -13114.854    253.63287    253.63287    67814.153    67814.153    1046.9983    1046.9983 
   87000   -12978.685   -12978.685   -13114.428   -13114.428    262.60414    262.60414    67896.917    67896.917   -46.625848   -46.625848 
Loop time of 121.313 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.712 ns/day, 33.698 hours/ns, 8.243 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.32     | 120.32     | 120.32     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19385    | 0.19385    | 0.19385    |   0.0 |  0.16
Output  | 0.0001764  | 0.0001764  | 0.0001764  |   0.0 |  0.00
Modify  | 0.6943     | 0.6943     | 0.6943     |   0.0 |  0.57
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:        8252.00 ave        8252 max        8252 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:      947204.0 ave      947204 max      947204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 947204
Ave neighs/atom = 236.80100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.937914498632, Press = 0.455234250534475
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 
   87000   -12978.685   -12978.685   -13114.428   -13114.428    262.60414    262.60414    67896.917    67896.917   -46.625848   -46.625848 
   88000   -12984.026   -12984.026   -13116.203   -13116.203      255.705      255.705    67925.112    67925.112   -678.49638   -678.49638 
Loop time of 123.089 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.702 ns/day, 34.191 hours/ns, 8.124 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.08     | 122.08     | 122.08     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19663    | 0.19663    | 0.19663    |   0.0 |  0.16
Output  | 0.00022696 | 0.00022696 | 0.00022696 |   0.0 |  0.00
Modify  | 0.71324    | 0.71324    | 0.71324    |   0.0 |  0.58
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:        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:      945962.0 ave      945962 max      945962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945962
Ave neighs/atom = 236.49050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.941118920831, Press = 0.170938244769952
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 
   88000   -12984.026   -12984.026   -13116.203   -13116.203      255.705      255.705    67925.112    67925.112   -678.49638   -678.49638 
   89000   -12986.408   -12986.408   -13117.053   -13117.053    252.74159    252.74159    67901.661    67901.661   -418.65545   -418.65545 
Loop time of 117.444 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.736 ns/day, 32.623 hours/ns, 8.515 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    | 116.47     | 116.47     | 116.47     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19106    | 0.19106    | 0.19106    |   0.0 |  0.16
Output  | 0.00018211 | 0.00018211 | 0.00018211 |   0.0 |  0.00
Modify  | 0.68077    | 0.68077    | 0.68077    |   0.0 |  0.58
Other   |            | 0.1021     |            |       |  0.09

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:      945436.0 ave      945436 max      945436 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945436
Ave neighs/atom = 236.35900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.935352930272, Press = -0.163426539985876
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 
   89000   -12986.408   -12986.408   -13117.053   -13117.053    252.74159    252.74159    67901.661    67901.661   -418.65545   -418.65545 
   90000   -12982.201   -12982.201   -13111.938   -13111.938    250.98651    250.98651    67914.748    67914.748   -7.4233411   -7.4233411 
Loop time of 118.599 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.729 ns/day, 32.944 hours/ns, 8.432 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.61     | 117.61     | 117.61     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19365    | 0.19365    | 0.19365    |   0.0 |  0.16
Output  | 0.00017628 | 0.00017628 | 0.00017628 |   0.0 |  0.00
Modify  | 0.693      | 0.693      | 0.693      |   0.0 |  0.58
Other   |            | 0.1029     |            |       |  0.09

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:      945830.0 ave      945830 max      945830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945830
Ave neighs/atom = 236.45750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.918652678715, Press = 0.279241219828412
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 
   90000   -12982.201   -12982.201   -13111.938   -13111.938    250.98651    250.98651    67914.748    67914.748   -7.4233411   -7.4233411 
   91000   -12983.075   -12983.075   -13112.021   -13112.021    249.45525    249.45525    67953.614    67953.614   -601.34771   -601.34771 
Loop time of 121.148 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.713 ns/day, 33.652 hours/ns, 8.254 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    | 120.16     | 120.16     | 120.16     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19408    | 0.19408    | 0.19408    |   0.0 |  0.16
Output  | 0.00017875 | 0.00017875 | 0.00017875 |   0.0 |  0.00
Modify  | 0.6909     | 0.6909     | 0.6909     |   0.0 |  0.57
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:        8271.00 ave        8271 max        8271 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:      945568.0 ave      945568 max      945568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945568
Ave neighs/atom = 236.39200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.906716428494, Press = 0.125538518325678
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 
   91000   -12983.075   -12983.075   -13112.021   -13112.021    249.45525    249.45525    67953.614    67953.614   -601.34771   -601.34771 
   92000   -12984.086   -12984.086   -13112.413   -13112.413    248.25863    248.25863    68005.932    68005.932   -1434.1423   -1434.1423 
Loop time of 121.069 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.714 ns/day, 33.630 hours/ns, 8.260 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    | 120.07     | 120.07     | 120.07     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1955     | 0.1955     | 0.1955     |   0.0 |  0.16
Output  | 0.00017726 | 0.00017726 | 0.00017726 |   0.0 |  0.00
Modify  | 0.70116    | 0.70116    | 0.70116    |   0.0 |  0.58
Other   |            | 0.1037     |            |       |  0.09

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:      945024.0 ave      945024 max      945024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945024
Ave neighs/atom = 236.25600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.895962144037, Press = 0.298102208226178
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 
   92000   -12984.086   -12984.086   -13112.413   -13112.413    248.25863    248.25863    68005.932    68005.932   -1434.1423   -1434.1423 
   93000   -12980.214   -12980.214   -13110.525   -13110.525    252.09514    252.09514    67955.766    67955.766   -284.05558   -284.05558 
Loop time of 118.802 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.727 ns/day, 33.001 hours/ns, 8.417 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    | 117.82     | 117.82     | 117.82     |   0.0 | 99.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19153    | 0.19153    | 0.19153    |   0.0 |  0.16
Output  | 0.0001789  | 0.0001789  | 0.0001789  |   0.0 |  0.00
Modify  | 0.68622    | 0.68622    | 0.68622    |   0.0 |  0.58
Other   |            | 0.1021     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8227.00 ave        8227 max        8227 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:      944294.0 ave      944294 max      944294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 944294
Ave neighs/atom = 236.07350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.913241473024, Press = 0.427810486662942
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 
   93000   -12980.214   -12980.214   -13110.525   -13110.525    252.09514    252.09514    67955.766    67955.766   -284.05558   -284.05558 
   94000   -12983.677   -12983.677   -13115.249   -13115.249    254.53596    254.53596    67852.069    67852.069    542.67517    542.67517 
Loop time of 118.058 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.732 ns/day, 32.794 hours/ns, 8.470 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    | 117.07     | 117.07     | 117.07     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.193      | 0.193      | 0.193      |   0.0 |  0.16
Output  | 0.00017904 | 0.00017904 | 0.00017904 |   0.0 |  0.00
Modify  | 0.68777    | 0.68777    | 0.68777    |   0.0 |  0.58
Other   |            | 0.1023     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8222.00 ave        8222 max        8222 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:      945090.0 ave      945090 max      945090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945090
Ave neighs/atom = 236.27250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.92642031845, Press = 0.316421856574931
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 
   94000   -12983.677   -12983.677   -13115.249   -13115.249    254.53596    254.53596    67852.069    67852.069    542.67517    542.67517 
   95000   -12983.799   -12983.799   -13112.378   -13112.378    248.74512    248.74512    67844.422    67844.422    939.32622    939.32622 
Loop time of 116.351 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.743 ns/day, 32.320 hours/ns, 8.595 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    | 115.38     | 115.38     | 115.38     |   0.0 | 99.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19142    | 0.19142    | 0.19142    |   0.0 |  0.16
Output  | 0.00021882 | 0.00021882 | 0.00021882 |   0.0 |  0.00
Modify  | 0.67755    | 0.67755    | 0.67755    |   0.0 |  0.58
Other   |            | 0.1028     |            |       |  0.09

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:      946364.0 ave      946364 max      946364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946364
Ave neighs/atom = 236.59100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.932512669969, Press = 0.275344699075974
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 
   95000   -12983.799   -12983.799   -13112.378   -13112.378    248.74512    248.74512    67844.422    67844.422    939.32622    939.32622 
   96000   -12984.006   -12984.006   -13115.305   -13115.305    254.00768    254.00768    67942.034    67942.034   -833.77647   -833.77647 
Loop time of 115.502 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.748 ns/day, 32.084 hours/ns, 8.658 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    | 114.53     | 114.53     | 114.53     |   0.0 | 99.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18992    | 0.18992    | 0.18992    |   0.0 |  0.16
Output  | 0.00017737 | 0.00017737 | 0.00017737 |   0.0 |  0.00
Modify  | 0.67751    | 0.67751    | 0.67751    |   0.0 |  0.59
Other   |            | 0.1022     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8264.00 ave        8264 max        8264 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:      946714.0 ave      946714 max      946714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946714
Ave neighs/atom = 236.67850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.923033850786, Press = 0.164992968710239
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 
   96000   -12984.006   -12984.006   -13115.305   -13115.305    254.00768    254.00768    67942.034    67942.034   -833.77647   -833.77647 
   97000    -12988.14    -12988.14   -13116.626   -13116.626    248.56415    248.56415    67962.201    67962.201   -1358.3121   -1358.3121 
Loop time of 136.512 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.633 ns/day, 37.920 hours/ns, 7.325 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    | 135.46     | 135.46     | 135.46     |   0.0 | 99.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20543    | 0.20543    | 0.20543    |   0.0 |  0.15
Output  | 0.00018122 | 0.00018122 | 0.00018122 |   0.0 |  0.00
Modify  | 0.74553    | 0.74553    | 0.74553    |   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:        8237.00 ave        8237 max        8237 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:      945412.0 ave      945412 max      945412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945412
Ave neighs/atom = 236.35300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.916639072866, Press = 0.255508695872432
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 
   97000    -12988.14    -12988.14   -13116.626   -13116.626    248.56415    248.56415    67962.201    67962.201   -1358.3121   -1358.3121 
   98000   -12981.981   -12981.981   -13112.743   -13112.743    252.96818    252.96818    67934.283    67934.283   -295.44115   -295.44115 
Loop time of 141.053 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.613 ns/day, 39.181 hours/ns, 7.090 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 140.09     | 140.09     | 140.09     |   0.0 | 99.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19785    | 0.19785    | 0.19785    |   0.0 |  0.14
Output  | 0.00023317 | 0.00023317 | 0.00023317 |   0.0 |  0.00
Modify  | 0.67305    | 0.67305    | 0.67305    |   0.0 |  0.48
Other   |            | 0.09503    |            |       |  0.07

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8252.00 ave        8252 max        8252 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:      944718.0 ave      944718 max      944718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 944718
Ave neighs/atom = 236.17950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.907397260734, Press = 0.320544281177704
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 
   98000   -12981.981   -12981.981   -13112.743   -13112.743    252.96818    252.96818    67934.283    67934.283   -295.44115   -295.44115 
   99000   -12984.423   -12984.423    -13114.01    -13114.01    250.69342    250.69342     67916.69     67916.69     -280.901     -280.901 
Loop time of 143.737 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.601 ns/day, 39.927 hours/ns, 6.957 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.77     | 142.77     | 142.77     |   0.0 | 99.33
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19805    | 0.19805    | 0.19805    |   0.0 |  0.14
Output  | 0.00017964 | 0.00017964 | 0.00017964 |   0.0 |  0.00
Modify  | 0.67307    | 0.67307    | 0.67307    |   0.0 |  0.47
Other   |            | 0.095      |            |       |  0.07

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:      945286.0 ave      945286 max      945286 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945286
Ave neighs/atom = 236.32150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.896476042046, Press = 0.111107089774048
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 
   99000   -12984.423   -12984.423    -13114.01    -13114.01    250.69342    250.69342     67916.69     67916.69     -280.901     -280.901 
  100000   -12985.389   -12985.389   -13115.423   -13115.423    251.56053    251.56053    67902.475    67902.475   -258.38459   -258.38459 
Loop time of 143.768 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.601 ns/day, 39.936 hours/ns, 6.956 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.8      | 142.8      | 142.8      |   0.0 | 99.33
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19752    | 0.19752    | 0.19752    |   0.0 |  0.14
Output  | 0.00018026 | 0.00018026 | 0.00018026 |   0.0 |  0.00
Modify  | 0.67394    | 0.67394    | 0.67394    |   0.0 |  0.47
Other   |            | 0.09443    |            |       |  0.07

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:      945604.0 ave      945604 max      945604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945604
Ave neighs/atom = 236.40100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.908360150127, Press = 0.112821657183924
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 
  100000   -12985.389   -12985.389   -13115.423   -13115.423    251.56053    251.56053    67902.475    67902.475   -258.38459   -258.38459 
  101000   -12979.625   -12979.625   -13113.757   -13113.757    259.48629    259.48629    67941.758    67941.758    -560.6781    -560.6781 
Loop time of 143.778 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.601 ns/day, 39.938 hours/ns, 6.955 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.81     | 142.81     | 142.81     |   0.0 | 99.33
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19817    | 0.19817    | 0.19817    |   0.0 |  0.14
Output  | 0.00022945 | 0.00022945 | 0.00022945 |   0.0 |  0.00
Modify  | 0.67294    | 0.67294    | 0.67294    |   0.0 |  0.47
Other   |            | 0.09409    |            |       |  0.07

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:      945896.0 ave      945896 max      945896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945896
Ave neighs/atom = 236.47400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.924106956057, Press = 0.00521172061795989
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 
  101000   -12979.625   -12979.625   -13113.757   -13113.757    259.48629    259.48629    67941.758    67941.758    -560.6781    -560.6781 
  102000   -12985.261   -12985.261   -13113.788   -13113.788    248.64475    248.64475    67912.141    67912.141   -326.40272   -326.40272 
Loop time of 143.566 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.602 ns/day, 39.879 hours/ns, 6.965 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.6      | 142.6      | 142.6      |   0.0 | 99.33
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1984     | 0.1984     | 0.1984     |   0.0 |  0.14
Output  | 0.00018202 | 0.00018202 | 0.00018202 |   0.0 |  0.00
Modify  | 0.6739     | 0.6739     | 0.6739     |   0.0 |  0.47
Other   |            | 0.0946     |            |       |  0.07

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:      945098.0 ave      945098 max      945098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945098
Ave neighs/atom = 236.27450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.940339881641, Press = 0.234917017329349
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 
  102000   -12985.261   -12985.261   -13113.788   -13113.788    248.64475    248.64475    67912.141    67912.141   -326.40272   -326.40272 
  103000   -12978.898   -12978.898   -13109.218   -13109.218    252.11259    252.11259    67891.213    67891.213    749.64813    749.64813 
Loop time of 143.683 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.601 ns/day, 39.912 hours/ns, 6.960 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.72     | 142.72     | 142.72     |   0.0 | 99.33
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19826    | 0.19826    | 0.19826    |   0.0 |  0.14
Output  | 0.0001787  | 0.0001787  | 0.0001787  |   0.0 |  0.00
Modify  | 0.67332    | 0.67332    | 0.67332    |   0.0 |  0.47
Other   |            | 0.09467    |            |       |  0.07

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8221.00 ave        8221 max        8221 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:      945666.0 ave      945666 max      945666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945666
Ave neighs/atom = 236.41650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.954412412926, Press = 0.593227343016862
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 
  103000   -12978.898   -12978.898   -13109.218   -13109.218    252.11259    252.11259    67891.213    67891.213    749.64813    749.64813 
  104000   -12982.059   -12982.059   -13113.594   -13113.594    254.46394    254.46394    67916.042    67916.042   -120.06313   -120.06313 
Loop time of 143.819 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.601 ns/day, 39.950 hours/ns, 6.953 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.85     | 142.85     | 142.85     |   0.0 | 99.33
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19816    | 0.19816    | 0.19816    |   0.0 |  0.14
Output  | 0.000182   | 0.000182   | 0.000182   |   0.0 |  0.00
Modify  | 0.67296    | 0.67296    | 0.67296    |   0.0 |  0.47
Other   |            | 0.0949     |            |       |  0.07

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:      945910.0 ave      945910 max      945910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945910
Ave neighs/atom = 236.47750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.955600654951, Press = 0.585931375636436
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 
  104000   -12982.059   -12982.059   -13113.594   -13113.594    254.46394    254.46394    67916.042    67916.042   -120.06313   -120.06313 
  105000   -12982.904   -12982.904   -13114.257   -13114.257    254.11083    254.11083    67878.329    67878.329    284.46967    284.46967 
Loop time of 143.536 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.602 ns/day, 39.871 hours/ns, 6.967 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.57     | 142.57     | 142.57     |   0.0 | 99.33
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1996     | 0.1996     | 0.1996     |   0.0 |  0.14
Output  | 0.00017826 | 0.00017826 | 0.00017826 |   0.0 |  0.00
Modify  | 0.67357    | 0.67357    | 0.67357    |   0.0 |  0.47
Other   |            | 0.09344    |            |       |  0.07

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8279.00 ave        8279 max        8279 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:      945604.0 ave      945604 max      945604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945604
Ave neighs/atom = 236.40100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.945882449192, Press = 0.474548355805347
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 
  105000   -12982.904   -12982.904   -13114.257   -13114.257    254.11083    254.11083    67878.329    67878.329    284.46967    284.46967 
  106000   -12984.395   -12984.395    -13116.81    -13116.81    256.16496    256.16496    67848.189    67848.189    445.31533    445.31533 
Loop time of 143.408 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.602 ns/day, 39.836 hours/ns, 6.973 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    | 142.44     | 142.44     | 142.44     |   0.0 | 99.33
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19934    | 0.19934    | 0.19934    |   0.0 |  0.14
Output  | 0.00018007 | 0.00018007 | 0.00018007 |   0.0 |  0.00
Modify  | 0.67286    | 0.67286    | 0.67286    |   0.0 |  0.47
Other   |            | 0.09404    |            |       |  0.07

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:      946304.0 ave      946304 max      946304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946304
Ave neighs/atom = 236.57600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.933208020969, Press = 0.378066445825638
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 
  106000   -12984.395   -12984.395    -13116.81    -13116.81    256.16496    256.16496    67848.189    67848.189    445.31533    445.31533 
  107000   -12985.449   -12985.449    -13116.38    -13116.38    253.29346    253.29346    67816.726    67816.726    971.48049    971.48049 
Loop time of 139.405 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.620 ns/day, 38.724 hours/ns, 7.173 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.44     | 138.44     | 138.44     |   0.0 | 99.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1975     | 0.1975     | 0.1975     |   0.0 |  0.14
Output  | 0.00017812 | 0.00017812 | 0.00017812 |   0.0 |  0.00
Modify  | 0.6718     | 0.6718     | 0.6718     |   0.0 |  0.48
Other   |            | 0.09581    |            |       |  0.07

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:      946746.0 ave      946746 max      946746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946746
Ave neighs/atom = 236.68650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.934599006406, Press = 0.370317196817256
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 
  107000   -12985.449   -12985.449    -13116.38    -13116.38    253.29346    253.29346    67816.726    67816.726    971.48049    971.48049 
  108000   -12980.773   -12980.773   -13112.837   -13112.837    255.48606    255.48606    67812.182    67812.182    1413.6724    1413.6724 
Loop time of 136.615 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.632 ns/day, 37.949 hours/ns, 7.320 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    | 135.65     | 135.65     | 135.65     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19762    | 0.19762    | 0.19762    |   0.0 |  0.14
Output  | 0.00018523 | 0.00018523 | 0.00018523 |   0.0 |  0.00
Modify  | 0.67306    | 0.67306    | 0.67306    |   0.0 |  0.49
Other   |            | 0.09557    |            |       |  0.07

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8231.00 ave        8231 max        8231 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:      947156.0 ave      947156 max      947156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 947156
Ave neighs/atom = 236.78900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.947153981532, Press = 0.28300252913232
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 
  108000   -12980.773   -12980.773   -13112.837   -13112.837    255.48606    255.48606    67812.182    67812.182    1413.6724    1413.6724 
  109000   -12985.561   -12985.561   -13115.318   -13115.318    251.02316    251.02316    67883.693    67883.693    99.847553    99.847553 
Loop time of 150.183 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.575 ns/day, 41.718 hours/ns, 6.659 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    | 149.01     | 149.01     | 149.01     |   0.0 | 99.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22198    | 0.22198    | 0.22198    |   0.0 |  0.15
Output  | 0.0001841  | 0.0001841  | 0.0001841  |   0.0 |  0.00
Modify  | 0.84341    | 0.84341    | 0.84341    |   0.0 |  0.56
Other   |            | 0.1069     |            |       |  0.07

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:      947028.0 ave      947028 max      947028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 947028
Ave neighs/atom = 236.75700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.942263788719, Press = 0.314548592288328
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 
  109000   -12985.561   -12985.561   -13115.318   -13115.318    251.02316    251.02316    67883.693    67883.693    99.847553    99.847553 
  110000   -12986.588   -12986.588   -13116.836   -13116.836    251.97494    251.97494    67878.641    67878.641   -67.165767   -67.165767 
Loop time of 141.966 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.609 ns/day, 39.435 hours/ns, 7.044 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    | 140.83     | 140.83     | 140.83     |   0.0 | 99.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21666    | 0.21666    | 0.21666    |   0.0 |  0.15
Output  | 0.00017891 | 0.00017891 | 0.00017891 |   0.0 |  0.00
Modify  | 0.81123    | 0.81123    | 0.81123    |   0.0 |  0.57
Other   |            | 0.1067     |            |       |  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:      945916.0 ave      945916 max      945916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 945916
Ave neighs/atom = 236.47900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.944357256161, Press = 0.178372820937541
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 
  110000   -12986.588   -12986.588   -13116.836   -13116.836    251.97494    251.97494    67878.641    67878.641   -67.165767   -67.165767 
  111000   -12983.024   -12983.024   -13112.589   -13112.589    250.65206    250.65206    67843.269    67843.269    976.27208    976.27208 
Loop time of 136.973 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.631 ns/day, 38.048 hours/ns, 7.301 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.01     | 136.01     | 136.01     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19695    | 0.19695    | 0.19695    |   0.0 |  0.14
Output  | 0.00018023 | 0.00018023 | 0.00018023 |   0.0 |  0.00
Modify  | 0.67146    | 0.67146    | 0.67146    |   0.0 |  0.49
Other   |            | 0.09737    |            |       |  0.07

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:      946246.0 ave      946246 max      946246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946246
Ave neighs/atom = 236.56150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.929464132291, Press = 0.209012778411302
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 
  111000   -12983.024   -12983.024   -13112.589   -13112.589    250.65206    250.65206    67843.269    67843.269    976.27208    976.27208 
  112000   -12986.103   -12986.103   -13114.643   -13114.643    248.66908    248.66908    67834.964    67834.964    690.73137    690.73137 
Loop time of 142.098 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.608 ns/day, 39.472 hours/ns, 7.037 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    | 141.09     | 141.09     | 141.09     |   0.0 | 99.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20162    | 0.20162    | 0.20162    |   0.0 |  0.14
Output  | 0.00052563 | 0.00052563 | 0.00052563 |   0.0 |  0.00
Modify  | 0.70651    | 0.70651    | 0.70651    |   0.0 |  0.50
Other   |            | 0.1002     |            |       |  0.07

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:      946706.0 ave      946706 max      946706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946706
Ave neighs/atom = 236.67650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.92194430827, Press = 0.351738538835285
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 
  112000   -12986.103   -12986.103   -13114.643   -13114.643    248.66908    248.66908    67834.964    67834.964    690.73137    690.73137 
  113000   -12985.148   -12985.148   -13115.963   -13115.963     253.0715     253.0715    67823.176    67823.176    761.72393    761.72393 
Loop time of 119.751 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.721 ns/day, 33.264 hours/ns, 8.351 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    | 118.75     | 118.75     | 118.75     |   0.0 | 99.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1927     | 0.1927     | 0.1927     |   0.0 |  0.16
Output  | 0.00017773 | 0.00017773 | 0.00017773 |   0.0 |  0.00
Modify  | 0.70192    | 0.70192    | 0.70192    |   0.0 |  0.59
Other   |            | 0.1026     |            |       |  0.09

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8216.00 ave        8216 max        8216 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:      946830.0 ave      946830 max      946830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946830
Ave neighs/atom = 236.70750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.934366297456, Press = 0.234701108107324
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 
  113000   -12985.148   -12985.148   -13115.963   -13115.963     253.0715     253.0715    67823.176    67823.176    761.72393    761.72393 
  114000   -12979.772   -12979.772   -13114.468   -13114.468     260.5785     260.5785    67841.285    67841.285    892.06208    892.06208 
Loop time of 112.185 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.163 hours/ns, 8.914 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.24     | 111.24     | 111.24     |   0.0 | 99.15
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18709    | 0.18709    | 0.18709    |   0.0 |  0.17
Output  | 0.00022175 | 0.00022175 | 0.00022175 |   0.0 |  0.00
Modify  | 0.66111    | 0.66111    | 0.66111    |   0.0 |  0.59
Other   |            | 0.1003     |            |       |  0.09

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:      947126.0 ave      947126 max      947126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 947126
Ave neighs/atom = 236.78150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.945264543151, Press = 0.167585999945025
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 
  114000   -12979.772   -12979.772   -13114.468   -13114.468     260.5785     260.5785    67841.285    67841.285    892.06208    892.06208 
  115000   -12982.946   -12982.946   -13115.767   -13115.767    256.94976    256.94976    67808.548    67808.548    1130.7522    1130.7522 
Loop time of 112.162 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.770 ns/day, 31.156 hours/ns, 8.916 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.22     | 111.22     | 111.22     |   0.0 | 99.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18582    | 0.18582    | 0.18582    |   0.0 |  0.17
Output  | 0.00017964 | 0.00017964 | 0.00017964 |   0.0 |  0.00
Modify  | 0.66023    | 0.66023    | 0.66023    |   0.0 |  0.59
Other   |            | 0.1006     |            |       |  0.09

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:      946660.0 ave      946660 max      946660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 946660
Ave neighs/atom = 236.66500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 252.961311708075, Press = 0.302142675388222
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 
  115000   -12982.946   -12982.946   -13115.767   -13115.767    256.94976    256.94976    67808.548    67808.548    1130.7522    1130.7522 
  116000   -12983.382   -12983.382   -13116.318   -13116.318    257.17481    257.17481    67876.391    67876.391    -5.393826    -5.393826 
Loop time of 111.987 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.772 ns/day, 31.108 hours/ns, 8.930 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.04     | 111.04     | 111.04     |   0.0 | 99.15
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18535    | 0.18535    | 0.18535    |   0.0 |  0.17
Output  | 0.00017595 | 0.00017595 | 0.00017595 |   0.0 |  0.00
Modify  | 0.66165    | 0.66165    | 0.66165    |   0.0 |  0.59
Other   |            | 0.101      |            |       |  0.09

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:      947220.0 ave      947220 max      947220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0