# 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 2.866965785622597*${_u_distance}
variable latticeconst_converted equal 2.866965785622597*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.8669657856226
Lattice spacing in x,y,z = 2.8669658 2.8669658 2.8669658
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 (28.669658 28.669658 28.669658)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (28.669658 28.669658 28.669658)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_BonnyTerentyevPasianot_2011_FeNiCr__MO_677715648236_000
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0    -7938.493    -7938.493   -8009.0725   -8009.0725       273.15       273.15    23565.005    23565.005    3199.1229    3199.1229 
    1000   -7995.3717   -7995.3717   -8065.4585   -8065.4585    271.24319    271.24319    21624.859    21624.859   -773.03609   -773.03609 
Loop time of 31.999 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.700 ns/day, 8.889 hours/ns, 31.251 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.295     | 31.295     | 31.295     |   0.0 | 97.80
Neigh   | 0.14295    | 0.14295    | 0.14295    |   0.0 |  0.45
Comm    | 0.1344     | 0.1344     | 0.1344     |   0.0 |  0.42
Output  | 0.00019852 | 0.00019852 | 0.00019852 |   0.0 |  0.00
Modify  | 0.36155    | 0.36155    | 0.36155    |   0.0 |  1.13
Other   |            | 0.0651     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5471.00 ave        5471 max        5471 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333288.0 ave      333288 max      333288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333288
Ave neighs/atom = 166.64400
Neighbor list builds = 3
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -7995.3717   -7995.3717   -8065.4585   -8065.4585    271.24319    271.24319    21624.859    21624.859   -773.03609   -773.03609 
    2000   -8034.7868   -8034.7868   -8104.3698   -8104.3698    269.29341    269.29341    21558.642    21558.642    931.99178    931.99178 
Loop time of 31.8487 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.713 ns/day, 8.847 hours/ns, 31.398 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.204     | 31.204     | 31.204     |   0.0 | 97.98
Neigh   | 0.095093   | 0.095093   | 0.095093   |   0.0 |  0.30
Comm    | 0.12976    | 0.12976    | 0.12976    |   0.0 |  0.41
Output  | 0.00018637 | 0.00018637 | 0.00018637 |   0.0 |  0.00
Modify  | 0.35498    | 0.35498    | 0.35498    |   0.0 |  1.11
Other   |            | 0.06435    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5419.00 ave        5419 max        5419 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332638.0 ave      332638 max      332638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332638
Ave neighs/atom = 166.31900
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -8034.7868   -8034.7868   -8104.3698   -8104.3698    269.29341    269.29341    21558.642    21558.642    931.99178    931.99178 
    3000   -8041.8946   -8041.8946    -8110.808    -8110.808      266.702      266.702    21526.953    21526.953    1167.2625    1167.2625 
Loop time of 31.8731 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.711 ns/day, 8.854 hours/ns, 31.374 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.237     | 31.237     | 31.237     |   0.0 | 98.00
Neigh   | 0.094546   | 0.094546   | 0.094546   |   0.0 |  0.30
Comm    | 0.12692    | 0.12692    | 0.12692    |   0.0 |  0.40
Output  | 0.0001962  | 0.0001962  | 0.0001962  |   0.0 |  0.00
Modify  | 0.35056    | 0.35056    | 0.35056    |   0.0 |  1.10
Other   |            | 0.06392    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5429.00 ave        5429 max        5429 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333822.0 ave      333822 max      333822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333822
Ave neighs/atom = 166.91100
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8041.8946   -8041.8946    -8110.808    -8110.808      266.702      266.702    21526.953    21526.953    1167.2625    1167.2625 
    4000    -8037.254    -8037.254   -8108.6248   -8108.6248    276.21235    276.21235    21583.526    21583.526   -613.11421   -613.11421 
Loop time of 32.7212 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.640 ns/day, 9.089 hours/ns, 30.561 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    | 32.163     | 32.163     | 32.163     |   0.0 | 98.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12921    | 0.12921    | 0.12921    |   0.0 |  0.39
Output  | 0.0002285  | 0.0002285  | 0.0002285  |   0.0 |  0.00
Modify  | 0.36432    | 0.36432    | 0.36432    |   0.0 |  1.11
Other   |            | 0.06494    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5419.00 ave        5419 max        5419 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      334124.0 ave      334124 max      334124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334124
Ave neighs/atom = 167.06200
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 = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000    -8037.254    -8037.254   -8108.6248   -8108.6248    276.21235    276.21235    21583.526    21583.526   -613.11421   -613.11421 
    5000   -8039.5187   -8039.5187   -8110.1316   -8110.1316    273.27904    273.27904    21548.126    21548.126    204.61672    204.61672 
Loop time of 31.3184 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.759 ns/day, 8.700 hours/ns, 31.930 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.779     | 30.779     | 30.779     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12591    | 0.12591    | 0.12591    |   0.0 |  0.40
Output  | 0.00015158 | 0.00015158 | 0.00015158 |   0.0 |  0.00
Modify  | 0.34919    | 0.34919    | 0.34919    |   0.0 |  1.11
Other   |            | 0.06437    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5409.00 ave        5409 max        5409 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333096.0 ave      333096 max      333096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333096
Ave neighs/atom = 166.54800
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 = 270.694740868954, Press = -1019.37489256109
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8039.5187   -8039.5187   -8110.1316   -8110.1316    273.27904    273.27904    21548.126    21548.126    204.61672    204.61672 
    6000   -8039.6638   -8039.6638   -8109.5857   -8109.5857    270.60496    270.60496    21624.966    21624.966   -3778.3517   -3778.3517 
Loop time of 32.8459 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.630 ns/day, 9.124 hours/ns, 30.445 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.273     | 32.273     | 32.273     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12913    | 0.12913    | 0.12913    |   0.0 |  0.39
Output  | 0.0001552  | 0.0001552  | 0.0001552  |   0.0 |  0.00
Modify  | 0.37933    | 0.37933    | 0.37933    |   0.0 |  1.15
Other   |            | 0.06429    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5416.00 ave        5416 max        5416 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333600.0 ave      333600 max      333600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333600
Ave neighs/atom = 166.80000
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 = 271.591695318764, Press = -115.136702830677
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8039.6638   -8039.6638   -8109.5857   -8109.5857    270.60496    270.60496    21624.966    21624.966   -3778.3517   -3778.3517 
    7000   -8035.8021   -8035.8021   -8107.0854   -8107.0854    275.87395    275.87395    21585.629    21585.629   -1619.7215   -1619.7215 
Loop time of 32.8015 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.634 ns/day, 9.112 hours/ns, 30.486 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    | 32.228     | 32.228     | 32.228     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12943    | 0.12943    | 0.12943    |   0.0 |  0.39
Output  | 0.0001541  | 0.0001541  | 0.0001541  |   0.0 |  0.00
Modify  | 0.38003    | 0.38003    | 0.38003    |   0.0 |  1.16
Other   |            | 0.06429    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5416.00 ave        5416 max        5416 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332484.0 ave      332484 max      332484 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332484
Ave neighs/atom = 166.24200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 271.643466228962, Press = -17.9653966172685
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8035.8021   -8035.8021   -8107.0854   -8107.0854    275.87395    275.87395    21585.629    21585.629   -1619.7215   -1619.7215 
    8000   -8040.9898   -8040.9898   -8111.2137   -8111.2137    271.77358    271.77358     21555.22     21555.22    77.687635    77.687635 
Loop time of 32.1928 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.684 ns/day, 8.942 hours/ns, 31.063 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.623     | 31.623     | 31.623     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12834    | 0.12834    | 0.12834    |   0.0 |  0.40
Output  | 0.00019336 | 0.00019336 | 0.00019336 |   0.0 |  0.00
Modify  | 0.37586    | 0.37586    | 0.37586    |   0.0 |  1.17
Other   |            | 0.06499    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5413.00 ave        5413 max        5413 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332884.0 ave      332884 max      332884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332884
Ave neighs/atom = 166.44200
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 = 272.470483211039, Press = 13.1810474543309
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8040.9898   -8040.9898   -8111.2137   -8111.2137    271.77358    271.77358     21555.22     21555.22    77.687635    77.687635 
    9000   -8037.4247   -8037.4247   -8109.7734   -8109.7734    279.99684    279.99684    21534.906    21534.906    1500.1167    1500.1167 
Loop time of 33.0838 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.612 ns/day, 9.190 hours/ns, 30.226 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.497     | 32.497     | 32.497     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13008    | 0.13008    | 0.13008    |   0.0 |  0.39
Output  | 0.00015318 | 0.00015318 | 0.00015318 |   0.0 |  0.00
Modify  | 0.39092    | 0.39092    | 0.39092    |   0.0 |  1.18
Other   |            | 0.06538    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5417.00 ave        5417 max        5417 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333440.0 ave      333440 max      333440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333440
Ave neighs/atom = 166.72000
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 = 272.468949318361, Press = -15.5521576926041
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -8037.4247   -8037.4247   -8109.7734   -8109.7734    279.99684    279.99684    21534.906    21534.906    1500.1167    1500.1167 
   10000   -8038.6343   -8038.6343     -8108.51     -8108.51    270.42611    270.42611    21596.312    21596.312   -1896.1543   -1896.1543 
Loop time of 33.6053 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.571 ns/day, 9.335 hours/ns, 29.757 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    | 33.016     | 33.016     | 33.016     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13223    | 0.13223    | 0.13223    |   0.0 |  0.39
Output  | 0.0001542  | 0.0001542  | 0.0001542  |   0.0 |  0.00
Modify  | 0.39194    | 0.39194    | 0.39194    |   0.0 |  1.17
Other   |            | 0.06496    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5421.00 ave        5421 max        5421 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333784.0 ave      333784 max      333784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333784
Ave neighs/atom = 166.89200
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 = 272.515379978594, Press = -17.3602694359009
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8038.6343   -8038.6343     -8108.51     -8108.51    270.42611    270.42611    21596.312    21596.312   -1896.1543   -1896.1543 
   11000   -8042.2998   -8042.2998   -8111.7913   -8111.7913    268.93905    268.93905    21583.114    21583.114   -2374.7032   -2374.7032 
Loop time of 32.3243 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.673 ns/day, 8.979 hours/ns, 30.936 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    | 31.752     | 31.752     | 31.752     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12779    | 0.12779    | 0.12779    |   0.0 |  0.40
Output  | 0.00015604 | 0.00015604 | 0.00015604 |   0.0 |  0.00
Modify  | 0.38071    | 0.38071    | 0.38071    |   0.0 |  1.18
Other   |            | 0.06401    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5398.00 ave        5398 max        5398 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332552.0 ave      332552 max      332552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332552
Ave neighs/atom = 166.27600
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 = 272.385592249112, Press = -8.04996355933413
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8042.2998   -8042.2998   -8111.7913   -8111.7913    268.93905    268.93905    21583.114    21583.114   -2374.7032   -2374.7032 
   12000   -8037.2107   -8037.2107   -8106.3172   -8106.3172    267.44912    267.44912    21576.112    21576.112     436.7667     436.7667 
Loop time of 32.6726 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.644 ns/day, 9.076 hours/ns, 30.607 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    | 32.097     | 32.097     | 32.097     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13015    | 0.13015    | 0.13015    |   0.0 |  0.40
Output  | 0.00015252 | 0.00015252 | 0.00015252 |   0.0 |  0.00
Modify  | 0.38068    | 0.38068    | 0.38068    |   0.0 |  1.17
Other   |            | 0.0648     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5422.00 ave        5422 max        5422 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332890.0 ave      332890 max      332890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332890
Ave neighs/atom = 166.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 = 272.283499881671, Press = 3.36331133703683
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8037.2107   -8037.2107   -8106.3172   -8106.3172    267.44912    267.44912    21576.112    21576.112     436.7667     436.7667 
   13000   -8039.8835   -8039.8835   -8110.1397   -8110.1397    271.89861    271.89861    21565.956    21565.956   -1090.7935   -1090.7935 
Loop time of 32.787 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.635 ns/day, 9.108 hours/ns, 30.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    | 32.209     | 32.209     | 32.209     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12974    | 0.12974    | 0.12974    |   0.0 |  0.40
Output  | 0.0001551  | 0.0001551  | 0.0001551  |   0.0 |  0.00
Modify  | 0.3835     | 0.3835     | 0.3835     |   0.0 |  1.17
Other   |            | 0.06482    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5416.00 ave        5416 max        5416 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333156.0 ave      333156 max      333156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333156
Ave neighs/atom = 166.57800
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 = 272.639324695736, Press = -3.46920096278557
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8039.8835   -8039.8835   -8110.1397   -8110.1397    271.89861    271.89861    21565.956    21565.956   -1090.7935   -1090.7935 
   14000   -8041.9074   -8041.9074   -8110.7267   -8110.7267    266.33779    266.33779    21520.032    21520.032    1663.1862    1663.1862 
Loop time of 31.9863 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.701 ns/day, 8.885 hours/ns, 31.263 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.422     | 31.422     | 31.422     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12693    | 0.12693    | 0.12693    |   0.0 |  0.40
Output  | 0.0001518  | 0.0001518  | 0.0001518  |   0.0 |  0.00
Modify  | 0.37276    | 0.37276    | 0.37276    |   0.0 |  1.17
Other   |            | 0.06455    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5412.00 ave        5412 max        5412 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333078.0 ave      333078 max      333078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333078
Ave neighs/atom = 166.53900
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 = 272.642010241055, Press = -7.95216932598287
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8041.9074   -8041.9074   -8110.7267   -8110.7267    266.33779    266.33779    21520.032    21520.032    1663.1862    1663.1862 
   15000    -8037.329    -8037.329   -8108.2198   -8108.2198    274.35477    274.35477    21538.441    21538.441    1884.4584    1884.4584 
Loop time of 31.8722 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.711 ns/day, 8.853 hours/ns, 31.375 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.31      | 31.31      | 31.31      |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12636    | 0.12636    | 0.12636    |   0.0 |  0.40
Output  | 0.00015408 | 0.00015408 | 0.00015408 |   0.0 |  0.00
Modify  | 0.37171    | 0.37171    | 0.37171    |   0.0 |  1.17
Other   |            | 0.06402    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5426.00 ave        5426 max        5426 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      334364.0 ave      334364 max      334364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334364
Ave neighs/atom = 167.18200
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 = 272.528082419388, Press = -7.79985629941859
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000    -8037.329    -8037.329   -8108.2198   -8108.2198    274.35477    274.35477    21538.441    21538.441    1884.4584    1884.4584 
   16000   -8041.2932   -8041.2932   -8110.0984   -8110.0984    266.28319    266.28319    21638.452    21638.452   -4825.2304   -4825.2304 
Loop time of 32.2406 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.680 ns/day, 8.956 hours/ns, 31.017 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.672     | 31.672     | 31.672     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12843    | 0.12843    | 0.12843    |   0.0 |  0.40
Output  | 0.00015382 | 0.00015382 | 0.00015382 |   0.0 |  0.00
Modify  | 0.37549    | 0.37549    | 0.37549    |   0.0 |  1.16
Other   |            | 0.06419    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5411.00 ave        5411 max        5411 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      334010.0 ave      334010 max      334010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334010
Ave neighs/atom = 167.00500
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 = 272.427013377773, Press = -2.01673950598826
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8041.2932   -8041.2932   -8110.0984   -8110.0984    266.28319    266.28319    21638.452    21638.452   -4825.2304   -4825.2304 
   17000   -8039.6979   -8039.6979   -8110.1908   -8110.1908    272.81483    272.81483    21559.584    21559.584    791.67951    791.67951 
Loop time of 32.7746 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.636 ns/day, 9.104 hours/ns, 30.511 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.202     | 32.202     | 32.202     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12905    | 0.12905    | 0.12905    |   0.0 |  0.39
Output  | 0.0001495  | 0.0001495  | 0.0001495  |   0.0 |  0.00
Modify  | 0.379      | 0.379      | 0.379      |   0.0 |  1.16
Other   |            | 0.0646     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5423.00 ave        5423 max        5423 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332462.0 ave      332462 max      332462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332462
Ave neighs/atom = 166.23100
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 = 272.447094896522, Press = 3.38556008556742
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8039.6979   -8039.6979   -8110.1908   -8110.1908    272.81483    272.81483    21559.584    21559.584    791.67951    791.67951 
   18000   -8037.0492   -8037.0492   -8108.8363   -8108.8363     277.8237     277.8237    21547.335    21547.335    1236.4536    1236.4536 
Loop time of 31.7905 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.718 ns/day, 8.831 hours/ns, 31.456 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.231     | 31.231     | 31.231     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1261     | 0.1261     | 0.1261     |   0.0 |  0.40
Output  | 0.00015566 | 0.00015566 | 0.00015566 |   0.0 |  0.00
Modify  | 0.3689     | 0.3689     | 0.3689     |   0.0 |  1.16
Other   |            | 0.06454    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5413.00 ave        5413 max        5413 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333538.0 ave      333538 max      333538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333538
Ave neighs/atom = 166.76900
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 = 272.446640853008, Press = 1.07587822943967
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8037.0492   -8037.0492   -8108.8363   -8108.8363     277.8237     277.8237    21547.335    21547.335    1236.4536    1236.4536 
   19000   -8037.1415   -8037.1415   -8109.5999   -8109.5999    280.42132    280.42132    21555.208    21555.208    331.39449    331.39449 
Loop time of 32.8908 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.627 ns/day, 9.136 hours/ns, 30.404 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    | 32.311     | 32.311     | 32.311     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13029    | 0.13029    | 0.13029    |   0.0 |  0.40
Output  | 0.00015237 | 0.00015237 | 0.00015237 |   0.0 |  0.00
Modify  | 0.38385    | 0.38385    | 0.38385    |   0.0 |  1.17
Other   |            | 0.06534    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5419.00 ave        5419 max        5419 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333524.0 ave      333524 max      333524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333524
Ave neighs/atom = 166.76200
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 = 272.559248059144, Press = -3.68707294066933
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8037.1415   -8037.1415   -8109.5999   -8109.5999    280.42132    280.42132    21555.208    21555.208    331.39449    331.39449 
   20000   -8037.5832   -8037.5832   -8107.9196   -8107.9196    272.20894    272.20894    21565.196    21565.196    959.15032    959.15032 
Loop time of 32.4045 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.666 ns/day, 9.001 hours/ns, 30.860 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.838     | 31.838     | 31.838     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12788    | 0.12788    | 0.12788    |   0.0 |  0.39
Output  | 0.00019626 | 0.00019626 | 0.00019626 |   0.0 |  0.00
Modify  | 0.37424    | 0.37424    | 0.37424    |   0.0 |  1.15
Other   |            | 0.06393    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5433.00 ave        5433 max        5433 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333562.0 ave      333562 max      333562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333562
Ave neighs/atom = 166.78100
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 = 272.659520709979, Press = -0.834626692858371
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8037.5832   -8037.5832   -8107.9196   -8107.9196    272.20894    272.20894    21565.196    21565.196    959.15032    959.15032 
   21000   -8037.9063   -8037.9063    -8106.847    -8106.847    266.80765    266.80765    21564.691    21564.691    1823.4957    1823.4957 
Loop time of 33.053 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.614 ns/day, 9.181 hours/ns, 30.254 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.475     | 32.475     | 32.475     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12985    | 0.12985    | 0.12985    |   0.0 |  0.39
Output  | 0.00019461 | 0.00019461 | 0.00019461 |   0.0 |  0.00
Modify  | 0.3841     | 0.3841     | 0.3841     |   0.0 |  1.16
Other   |            | 0.06353    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5425.00 ave        5425 max        5425 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333364.0 ave      333364 max      333364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333364
Ave neighs/atom = 166.68200
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 = 272.636162945936, Press = 0.083465019233632
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8037.9063   -8037.9063    -8106.847    -8106.847    266.80765    266.80765    21564.691    21564.691    1823.4957    1823.4957 
   22000   -8039.3931   -8039.3931    -8110.715    -8110.715    276.02328    276.02328    21544.002    21544.002    1212.9643    1212.9643 
Loop time of 32.5856 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.651 ns/day, 9.052 hours/ns, 30.688 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.019     | 32.019     | 32.019     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12701    | 0.12701    | 0.12701    |   0.0 |  0.39
Output  | 0.00019329 | 0.00019329 | 0.00019329 |   0.0 |  0.00
Modify  | 0.37596    | 0.37596    | 0.37596    |   0.0 |  1.15
Other   |            | 0.06296    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5402.00 ave        5402 max        5402 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333276.0 ave      333276 max      333276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333276
Ave neighs/atom = 166.63800
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 = 272.623686939025, Press = -1.85498394167041
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8039.3931   -8039.3931    -8110.715    -8110.715    276.02328    276.02328    21544.002    21544.002    1212.9643    1212.9643 
   23000   -8037.1583   -8037.1583   -8107.7356   -8107.7356    273.14126    273.14126    21587.554    21587.554   -1340.9917   -1340.9917 
Loop time of 32.4898 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.659 ns/day, 9.025 hours/ns, 30.779 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    | 31.918     | 31.918     | 31.918     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12878    | 0.12878    | 0.12878    |   0.0 |  0.40
Output  | 0.00015561 | 0.00015561 | 0.00015561 |   0.0 |  0.00
Modify  | 0.37899    | 0.37899    | 0.37899    |   0.0 |  1.17
Other   |            | 0.0643     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5424.00 ave        5424 max        5424 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333668.0 ave      333668 max      333668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333668
Ave neighs/atom = 166.83400
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 = 272.647752765581, Press = -4.6074651879499
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8037.1583   -8037.1583   -8107.7356   -8107.7356    273.14126    273.14126    21587.554    21587.554   -1340.9917   -1340.9917 
   24000   -8038.5448   -8038.5448   -8110.5712   -8110.5712    278.74952    278.74952    21565.553    21565.553    -450.9506    -450.9506 
Loop time of 33.3942 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.587 ns/day, 9.276 hours/ns, 29.945 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.806     | 32.806     | 32.806     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13165    | 0.13165    | 0.13165    |   0.0 |  0.39
Output  | 0.00015448 | 0.00015448 | 0.00015448 |   0.0 |  0.00
Modify  | 0.39178    | 0.39178    | 0.39178    |   0.0 |  1.17
Other   |            | 0.06489    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5412.00 ave        5412 max        5412 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332924.0 ave      332924 max      332924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332924
Ave neighs/atom = 166.46200
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 = 272.702869784548, Press = -0.0762076361432226
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8038.5448   -8038.5448   -8110.5712   -8110.5712    278.74952    278.74952    21565.553    21565.553    -450.9506    -450.9506 
   25000   -8038.8645   -8038.8645   -8110.3191   -8110.3191    276.53701    276.53701    21589.586    21589.586    -1117.198    -1117.198 
Loop time of 32.2952 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.675 ns/day, 8.971 hours/ns, 30.964 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.73      | 31.73      | 31.73      |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12808    | 0.12808    | 0.12808    |   0.0 |  0.40
Output  | 0.00015918 | 0.00015918 | 0.00015918 |   0.0 |  0.00
Modify  | 0.37326    | 0.37326    | 0.37326    |   0.0 |  1.16
Other   |            | 0.06405    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5410.00 ave        5410 max        5410 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333376.0 ave      333376 max      333376 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333376
Ave neighs/atom = 166.68800
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 = 272.606819042418, Press = -4.22831422825226
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8038.8645   -8038.8645   -8110.3191   -8110.3191    276.53701    276.53701    21589.586    21589.586    -1117.198    -1117.198 
   26000   -8039.9867   -8039.9867   -8110.2332   -8110.2332     271.8611     271.8611    21561.874    21561.874   -564.84581   -564.84581 
Loop time of 32.7003 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.642 ns/day, 9.083 hours/ns, 30.581 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    | 32.125     | 32.125     | 32.125     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12995    | 0.12995    | 0.12995    |   0.0 |  0.40
Output  | 0.00019249 | 0.00019249 | 0.00019249 |   0.0 |  0.00
Modify  | 0.38015    | 0.38015    | 0.38015    |   0.0 |  1.16
Other   |            | 0.06486    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5412.00 ave        5412 max        5412 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332884.0 ave      332884 max      332884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332884
Ave neighs/atom = 166.44200
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 = 272.594231142686, Press = -4.50172998071443
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -8039.9867   -8039.9867   -8110.2332   -8110.2332     271.8611     271.8611    21561.874    21561.874   -564.84581   -564.84581 
   27000   -8037.1254   -8037.1254   -8108.6671   -8108.6671    276.87388    276.87388    21556.081    21556.081    495.91465    495.91465 
Loop time of 31.9841 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.701 ns/day, 8.884 hours/ns, 31.266 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.416     | 31.416     | 31.416     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1274     | 0.1274     | 0.1274     |   0.0 |  0.40
Output  | 0.00015381 | 0.00015381 | 0.00015381 |   0.0 |  0.00
Modify  | 0.37575    | 0.37575    | 0.37575    |   0.0 |  1.17
Other   |            | 0.06458    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5447.00 ave        5447 max        5447 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333246.0 ave      333246 max      333246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333246
Ave neighs/atom = 166.62300
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 = 272.7057443497, Press = -1.94936669380567
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8037.1254   -8037.1254   -8108.6671   -8108.6671    276.87388    276.87388    21556.081    21556.081    495.91465    495.91465 
   28000   -8038.9603   -8038.9603   -8109.6438   -8109.6438    273.55223    273.55223    21529.375    21529.375    2586.3977    2586.3977 
Loop time of 32.8684 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.629 ns/day, 9.130 hours/ns, 30.424 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    | 32.286     | 32.286     | 32.286     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13032    | 0.13032    | 0.13032    |   0.0 |  0.40
Output  | 0.00015202 | 0.00015202 | 0.00015202 |   0.0 |  0.00
Modify  | 0.38682    | 0.38682    | 0.38682    |   0.0 |  1.18
Other   |            | 0.06536    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5410.00 ave        5410 max        5410 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333446.0 ave      333446 max      333446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333446
Ave neighs/atom = 166.72300
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 = 272.792627595474, Press = -1.31040698760052
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8038.9603   -8038.9603   -8109.6438   -8109.6438    273.55223    273.55223    21529.375    21529.375    2586.3977    2586.3977 
   29000   -8036.6366   -8036.6366   -8107.4613   -8107.4613    274.09889    274.09889     21584.15     21584.15   -1121.5366   -1121.5366 
Loop time of 32.7779 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.636 ns/day, 9.105 hours/ns, 30.508 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.205     | 32.205     | 32.205     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12953    | 0.12953    | 0.12953    |   0.0 |  0.40
Output  | 0.00015454 | 0.00015454 | 0.00015454 |   0.0 |  0.00
Modify  | 0.3792     | 0.3792     | 0.3792     |   0.0 |  1.16
Other   |            | 0.06426    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5404.00 ave        5404 max        5404 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      334228.0 ave      334228 max      334228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334228
Ave neighs/atom = 167.11400
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 = 272.871247696395, Press = -5.82156335731026
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8036.6366   -8036.6366   -8107.4613   -8107.4613    274.09889    274.09889     21584.15     21584.15   -1121.5366   -1121.5366 
   30000   -8038.8644   -8038.8644   -8108.6346   -8108.6346     270.0178     270.0178     21559.04     21559.04     515.8305     515.8305 
Loop time of 32.6796 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.644 ns/day, 9.078 hours/ns, 30.600 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    | 32.11      | 32.11      | 32.11      |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12753    | 0.12753    | 0.12753    |   0.0 |  0.39
Output  | 0.00015379 | 0.00015379 | 0.00015379 |   0.0 |  0.00
Modify  | 0.37806    | 0.37806    | 0.37806    |   0.0 |  1.16
Other   |            | 0.06418    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5412.00 ave        5412 max        5412 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333074.0 ave      333074 max      333074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333074
Ave neighs/atom = 166.53700
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 = 272.820584904313, Press = -2.99343953195996
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8038.8644   -8038.8644   -8108.6346   -8108.6346     270.0178     270.0178     21559.04     21559.04     515.8305     515.8305 
   31000   -8038.4411   -8038.4411   -8109.4172   -8109.4172     274.6846     274.6846    21519.492    21519.492    4429.7396    4429.7396 
Loop time of 32.322 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.673 ns/day, 8.978 hours/ns, 30.939 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    | 31.75      | 31.75      | 31.75      |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12797    | 0.12797    | 0.12797    |   0.0 |  0.40
Output  | 0.00019491 | 0.00019491 | 0.00019491 |   0.0 |  0.00
Modify  | 0.37844    | 0.37844    | 0.37844    |   0.0 |  1.17
Other   |            | 0.06496    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5417.00 ave        5417 max        5417 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333534.0 ave      333534 max      333534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333534
Ave neighs/atom = 166.76700
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 = 272.863381520636, Press = -2.45225264663312
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8038.4411   -8038.4411   -8109.4172   -8109.4172     274.6846     274.6846    21519.492    21519.492    4429.7396    4429.7396 
   32000   -8039.3243   -8039.3243   -8109.0784   -8109.0784    269.95553    269.95553    21557.977    21557.977    261.71289    261.71289 
Loop time of 33.0814 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.612 ns/day, 9.189 hours/ns, 30.228 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    | 32.51      | 32.51      | 32.51      |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12776    | 0.12776    | 0.12776    |   0.0 |  0.39
Output  | 0.00015525 | 0.00015525 | 0.00015525 |   0.0 |  0.00
Modify  | 0.37968    | 0.37968    | 0.37968    |   0.0 |  1.15
Other   |            | 0.06419    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5416.00 ave        5416 max        5416 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333960.0 ave      333960 max      333960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333960
Ave neighs/atom = 166.98000
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 = 272.915694276225, Press = -2.80915147612763
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -8039.3243   -8039.3243   -8109.0784   -8109.0784    269.95553    269.95553    21557.977    21557.977    261.71289    261.71289 
   33000   -8042.3547   -8042.3547    -8111.087    -8111.087     266.0011     266.0011    21524.137    21524.137    2532.0565    2532.0565 
Loop time of 33.0658 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.613 ns/day, 9.185 hours/ns, 30.243 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.476     | 32.476     | 32.476     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13183    | 0.13183    | 0.13183    |   0.0 |  0.40
Output  | 0.00019363 | 0.00019363 | 0.00019363 |   0.0 |  0.00
Modify  | 0.39276    | 0.39276    | 0.39276    |   0.0 |  1.19
Other   |            | 0.06496    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5390.00 ave        5390 max        5390 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333470.0 ave      333470 max      333470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333470
Ave neighs/atom = 166.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 = 272.909277715271, Press = -2.15604299534244
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -8042.3547   -8042.3547    -8111.087    -8111.087     266.0011     266.0011    21524.137    21524.137    2532.0565    2532.0565 
   34000   -8038.4019   -8038.4019   -8108.9812   -8108.9812    273.14912    273.14912    21584.479    21584.479   -1357.0156   -1357.0156 
Loop time of 32.9897 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.619 ns/day, 9.164 hours/ns, 30.312 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    | 32.414     | 32.414     | 32.414     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12939    | 0.12939    | 0.12939    |   0.0 |  0.39
Output  | 0.00015398 | 0.00015398 | 0.00015398 |   0.0 |  0.00
Modify  | 0.38121    | 0.38121    | 0.38121    |   0.0 |  1.16
Other   |            | 0.06451    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5424.00 ave        5424 max        5424 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      334060.0 ave      334060 max      334060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334060
Ave neighs/atom = 167.03000
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 = 272.83523624226, Press = -4.59961464971711
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -8038.4019   -8038.4019   -8108.9812   -8108.9812    273.14912    273.14912    21584.479    21584.479   -1357.0156   -1357.0156 
   35000   -8040.0787   -8040.0787   -8110.1263   -8110.1263    271.09156    271.09156    21566.407    21566.407    187.56681    187.56681 
Loop time of 33.0024 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.618 ns/day, 9.167 hours/ns, 30.301 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    | 32.419     | 32.419     | 32.419     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13003    | 0.13003    | 0.13003    |   0.0 |  0.39
Output  | 0.0001561  | 0.0001561  | 0.0001561  |   0.0 |  0.00
Modify  | 0.38796    | 0.38796    | 0.38796    |   0.0 |  1.18
Other   |            | 0.06496    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5410.00 ave        5410 max        5410 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333168.0 ave      333168 max      333168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333168
Ave neighs/atom = 166.58400
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 = 272.847333909641, Press = -2.12840481731218
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8040.0787   -8040.0787   -8110.1263   -8110.1263    271.09156    271.09156    21566.407    21566.407    187.56681    187.56681 
   36000   -8038.9741   -8038.9741   -8109.4827   -8109.4827    272.87592    272.87592    21611.478    21611.478   -2488.4135   -2488.4135 
Loop time of 31.6858 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.727 ns/day, 8.802 hours/ns, 31.560 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    | 31.127     | 31.127     | 31.127     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12519    | 0.12519    | 0.12519    |   0.0 |  0.40
Output  | 0.00019529 | 0.00019529 | 0.00019529 |   0.0 |  0.00
Modify  | 0.36949    | 0.36949    | 0.36949    |   0.0 |  1.17
Other   |            | 0.06376    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5416.00 ave        5416 max        5416 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333476.0 ave      333476 max      333476 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333476
Ave neighs/atom = 166.73800
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 = 272.752364876913, Press = -2.22994582985269
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -8038.9741   -8038.9741   -8109.4827   -8109.4827    272.87592    272.87592    21611.478    21611.478   -2488.4135   -2488.4135 
   37000   -8038.6882   -8038.6882   -8109.8372   -8109.8372    275.35409    275.35409    21552.343    21552.343    633.62911    633.62911 
Loop time of 33.1674 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.605 ns/day, 9.213 hours/ns, 30.150 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    | 32.585     | 32.585     | 32.585     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13111    | 0.13111    | 0.13111    |   0.0 |  0.40
Output  | 0.00015532 | 0.00015532 | 0.00015532 |   0.0 |  0.00
Modify  | 0.38647    | 0.38647    | 0.38647    |   0.0 |  1.17
Other   |            | 0.06467    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5397.00 ave        5397 max        5397 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332604.0 ave      332604 max      332604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332604
Ave neighs/atom = 166.30200
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 = 272.775631335847, Press = -0.734277401720158
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -8038.6882   -8038.6882   -8109.8372   -8109.8372    275.35409    275.35409    21552.343    21552.343    633.62911    633.62911 
   38000   -8039.7499   -8039.7499   -8109.5025   -8109.5025    269.94987    269.94987    21574.261    21574.261   -42.210027   -42.210027 
Loop time of 32.3315 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.672 ns/day, 8.981 hours/ns, 30.930 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.759     | 31.759     | 31.759     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12921    | 0.12921    | 0.12921    |   0.0 |  0.40
Output  | 0.00019746 | 0.00019746 | 0.00019746 |   0.0 |  0.00
Modify  | 0.3782     | 0.3782     | 0.3782     |   0.0 |  1.17
Other   |            | 0.06443    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5408.00 ave        5408 max        5408 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333464.0 ave      333464 max      333464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333464
Ave neighs/atom = 166.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 = 272.723698683797, Press = -4.24083799382095
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -8039.7499   -8039.7499   -8109.5025   -8109.5025    269.94987    269.94987    21574.261    21574.261   -42.210027   -42.210027 
   39000   -8039.0962   -8039.0962   -8110.4351   -8110.4351    276.08878    276.08878    21576.581    21576.581   -1886.2628   -1886.2628 
Loop time of 31.9414 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.705 ns/day, 8.873 hours/ns, 31.307 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    | 31.381     | 31.381     | 31.381     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12684    | 0.12684    | 0.12684    |   0.0 |  0.40
Output  | 0.00019444 | 0.00019444 | 0.00019444 |   0.0 |  0.00
Modify  | 0.36957    | 0.36957    | 0.36957    |   0.0 |  1.16
Other   |            | 0.06392    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5406.00 ave        5406 max        5406 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333280.0 ave      333280 max      333280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333280
Ave neighs/atom = 166.64000
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 = 272.746756219823, Press = -2.61809742583932
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8039.0962   -8039.0962   -8110.4351   -8110.4351    276.08878    276.08878    21576.581    21576.581   -1886.2628   -1886.2628 
   40000   -8040.1471   -8040.1471   -8109.1763   -8109.1763    267.15011    267.15011    21544.513    21544.513    1320.8788    1320.8788 
Loop time of 32.2176 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.682 ns/day, 8.949 hours/ns, 31.039 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    | 31.651     | 31.651     | 31.651     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12634    | 0.12634    | 0.12634    |   0.0 |  0.39
Output  | 0.00015285 | 0.00015285 | 0.00015285 |   0.0 |  0.00
Modify  | 0.37582    | 0.37582    | 0.37582    |   0.0 |  1.17
Other   |            | 0.0642     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5410.00 ave        5410 max        5410 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332858.0 ave      332858 max      332858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332858
Ave neighs/atom = 166.42900
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 = 272.719930363059, Press = -2.38793216980207
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -8040.1471   -8040.1471   -8109.1763   -8109.1763    267.15011    267.15011    21544.513    21544.513    1320.8788    1320.8788 
   41000   -8037.6531   -8037.6531   -8108.6515   -8108.6515    274.77139    274.77139    21552.289    21552.289    2014.2017    2014.2017 
Loop time of 32.8553 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.630 ns/day, 9.126 hours/ns, 30.436 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    | 32.281     | 32.281     | 32.281     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12821    | 0.12821    | 0.12821    |   0.0 |  0.39
Output  | 0.00019751 | 0.00019751 | 0.00019751 |   0.0 |  0.00
Modify  | 0.38134    | 0.38134    | 0.38134    |   0.0 |  1.16
Other   |            | 0.06472    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5409.00 ave        5409 max        5409 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333640.0 ave      333640 max      333640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333640
Ave neighs/atom = 166.82000
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 = 272.739930641716, Press = -0.347326952188848
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -8037.6531   -8037.6531   -8108.6515   -8108.6515    274.77139    274.77139    21552.289    21552.289    2014.2017    2014.2017 
   42000   -8040.4046   -8040.4046   -8112.9624   -8112.9624     280.8064     280.8064    21582.569    21582.569   -2295.9866   -2295.9866 
Loop time of 33.0771 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.612 ns/day, 9.188 hours/ns, 30.232 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.498     | 32.498     | 32.498     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12951    | 0.12951    | 0.12951    |   0.0 |  0.39
Output  | 0.00015495 | 0.00015495 | 0.00015495 |   0.0 |  0.00
Modify  | 0.38419    | 0.38419    | 0.38419    |   0.0 |  1.16
Other   |            | 0.06474    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5405.00 ave        5405 max        5405 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      334060.0 ave      334060 max      334060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334060
Ave neighs/atom = 167.03000
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 = 272.807085172419, Press = -2.96453631133812
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -8040.4046   -8040.4046   -8112.9624   -8112.9624     280.8064     280.8064    21582.569    21582.569   -2295.9866   -2295.9866 
   43000   -8039.6152   -8039.6152   -8110.5573   -8110.5573     274.5531     274.5531    21526.782    21526.782    707.97704    707.97704 
Loop time of 33.6951 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.564 ns/day, 9.360 hours/ns, 29.678 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    | 33.107     | 33.107     | 33.107     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13148    | 0.13148    | 0.13148    |   0.0 |  0.39
Output  | 0.0001573  | 0.0001573  | 0.0001573  |   0.0 |  0.00
Modify  | 0.39226    | 0.39226    | 0.39226    |   0.0 |  1.16
Other   |            | 0.06449    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5394.00 ave        5394 max        5394 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333044.0 ave      333044 max      333044 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333044
Ave neighs/atom = 166.52200
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 = 272.76682038433, Press = -1.64121699799931
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8039.6152   -8039.6152   -8110.5573   -8110.5573     274.5531     274.5531    21526.782    21526.782    707.97704    707.97704 
   44000   -8037.3184   -8037.3184   -8107.9564   -8107.9564     273.3762     273.3762    21584.505    21584.505   -75.264661   -75.264661 
Loop time of 32.9443 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.623 ns/day, 9.151 hours/ns, 30.354 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.356     | 32.356     | 32.356     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13047    | 0.13047    | 0.13047    |   0.0 |  0.40
Output  | 0.00015247 | 0.00015247 | 0.00015247 |   0.0 |  0.00
Modify  | 0.39152    | 0.39152    | 0.39152    |   0.0 |  1.19
Other   |            | 0.06583    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5426.00 ave        5426 max        5426 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333998.0 ave      333998 max      333998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333998
Ave neighs/atom = 166.99900
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 = 272.802839334448, Press = -1.02640455874024
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -8037.3184   -8037.3184   -8107.9564   -8107.9564     273.3762     273.3762    21584.505    21584.505   -75.264661   -75.264661 
   45000   -8039.0175   -8039.0175   -8108.7222   -8108.7222    269.76454    269.76454    21549.668    21549.668    2253.1295    2253.1295 
Loop time of 32.8522 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.630 ns/day, 9.126 hours/ns, 30.439 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    | 32.274     | 32.274     | 32.274     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12929    | 0.12929    | 0.12929    |   0.0 |  0.39
Output  | 0.00015187 | 0.00015187 | 0.00015187 |   0.0 |  0.00
Modify  | 0.38355    | 0.38355    | 0.38355    |   0.0 |  1.17
Other   |            | 0.06482    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5411.00 ave        5411 max        5411 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333100.0 ave      333100 max      333100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333100
Ave neighs/atom = 166.55000
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 = 272.828510097471, Press = -2.17108370714165
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -8039.0175   -8039.0175   -8108.7222   -8108.7222    269.76454    269.76454    21549.668    21549.668    2253.1295    2253.1295 
   46000   -8037.6082   -8037.6082   -8109.9451   -8109.9451     279.9515     279.9515    21514.203    21514.203    2375.5433    2375.5433 
Loop time of 32.1423 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.688 ns/day, 8.928 hours/ns, 31.112 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.586     | 31.586     | 31.586     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12722    | 0.12722    | 0.12722    |   0.0 |  0.40
Output  | 0.00015387 | 0.00015387 | 0.00015387 |   0.0 |  0.00
Modify  | 0.36591    | 0.36591    | 0.36591    |   0.0 |  1.14
Other   |            | 0.06345    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5393.00 ave        5393 max        5393 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333608.0 ave      333608 max      333608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333608
Ave neighs/atom = 166.80400
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 = 272.846086239266, Press = -2.60584693930906
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -8037.6082   -8037.6082   -8109.9451   -8109.9451     279.9515     279.9515    21514.203    21514.203    2375.5433    2375.5433 
   47000   -8038.9226   -8038.9226   -8109.0518   -8109.0518    271.40735    271.40735    21612.589    21612.589   -2700.4141   -2700.4141 
Loop time of 32.1722 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.686 ns/day, 8.937 hours/ns, 31.083 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    | 31.602     | 31.602     | 31.602     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12876    | 0.12876    | 0.12876    |   0.0 |  0.40
Output  | 0.00015592 | 0.00015592 | 0.00015592 |   0.0 |  0.00
Modify  | 0.37725    | 0.37725    | 0.37725    |   0.0 |  1.17
Other   |            | 0.06441    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5440.00 ave        5440 max        5440 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      334158.0 ave      334158 max      334158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334158
Ave neighs/atom = 167.07900
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 = 272.851639366427, Press = -2.35015967774137
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -8038.9226   -8038.9226   -8109.0518   -8109.0518    271.40735    271.40735    21612.589    21612.589   -2700.4141   -2700.4141 
   48000   -8037.9695   -8037.9695   -8109.3761   -8109.3761    276.35081    276.35081    21557.804    21557.804    2003.8605    2003.8605 
Loop time of 32.694 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.643 ns/day, 9.082 hours/ns, 30.587 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.117     | 32.117     | 32.117     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12879    | 0.12879    | 0.12879    |   0.0 |  0.39
Output  | 0.00015483 | 0.00015483 | 0.00015483 |   0.0 |  0.00
Modify  | 0.38304    | 0.38304    | 0.38304    |   0.0 |  1.17
Other   |            | 0.06485    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5394.00 ave        5394 max        5394 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332616.0 ave      332616 max      332616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332616
Ave neighs/atom = 166.30800
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 = 272.848851281168, Press = -0.684623060561856
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -8037.9695   -8037.9695   -8109.3761   -8109.3761    276.35081    276.35081    21557.804    21557.804    2003.8605    2003.8605 
   49000   -8040.7949   -8040.7949   -8110.3202   -8110.3202    269.07013    269.07013    21572.604    21572.604   -71.471886   -71.471886 
Loop time of 31.9895 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.701 ns/day, 8.886 hours/ns, 31.260 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    | 31.423     | 31.423     | 31.423     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12754    | 0.12754    | 0.12754    |   0.0 |  0.40
Output  | 0.00020866 | 0.00020866 | 0.00020866 |   0.0 |  0.00
Modify  | 0.37391    | 0.37391    | 0.37391    |   0.0 |  1.17
Other   |            | 0.06483    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5405.00 ave        5405 max        5405 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333452.0 ave      333452 max      333452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333452
Ave neighs/atom = 166.72600
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 = 272.818276263351, Press = -1.68649870299311
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -8040.7949   -8040.7949   -8110.3202   -8110.3202    269.07013    269.07013    21572.604    21572.604   -71.471886   -71.471886 
   50000   -8037.5398   -8037.5398   -8110.2073   -8110.2073    281.23066    281.23066    21597.001    21597.001   -3225.7682   -3225.7682 
Loop time of 32.7072 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.642 ns/day, 9.085 hours/ns, 30.574 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.131     | 32.131     | 32.131     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12941    | 0.12941    | 0.12941    |   0.0 |  0.40
Output  | 0.00015588 | 0.00015588 | 0.00015588 |   0.0 |  0.00
Modify  | 0.38197    | 0.38197    | 0.38197    |   0.0 |  1.17
Other   |            | 0.06497    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5422.00 ave        5422 max        5422 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333320.0 ave      333320 max      333320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333320
Ave neighs/atom = 166.66000
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 = 272.807627591707, Press = -2.3894232784849
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -8037.5398   -8037.5398   -8110.2073   -8110.2073    281.23066    281.23066    21597.001    21597.001   -3225.7682   -3225.7682 
   51000   -8038.2366   -8038.2366   -8109.5512   -8109.5512    275.99489    275.99489    21545.839    21545.839    1767.3947    1767.3947 
Loop time of 32.2228 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.681 ns/day, 8.951 hours/ns, 31.034 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    | 31.653     | 31.653     | 31.653     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12841    | 0.12841    | 0.12841    |   0.0 |  0.40
Output  | 0.00015586 | 0.00015586 | 0.00015586 |   0.0 |  0.00
Modify  | 0.37581    | 0.37581    | 0.37581    |   0.0 |  1.17
Other   |            | 0.06501    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5405.00 ave        5405 max        5405 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332842.0 ave      332842 max      332842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332842
Ave neighs/atom = 166.42100
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 = 272.817552316441, Press = -0.589625998621359
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -8038.2366   -8038.2366   -8109.5512   -8109.5512    275.99489    275.99489    21545.839    21545.839    1767.3947    1767.3947 
   52000   -8039.8337   -8039.8337   -8108.2215   -8108.2215    264.66794    264.66794    21616.572    21616.572   -2267.9257   -2267.9257 
Loop time of 33.14 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.607 ns/day, 9.206 hours/ns, 30.175 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    | 32.559     | 32.559     | 32.559     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12893    | 0.12893    | 0.12893    |   0.0 |  0.39
Output  | 0.0002009  | 0.0002009  | 0.0002009  |   0.0 |  0.00
Modify  | 0.38671    | 0.38671    | 0.38671    |   0.0 |  1.17
Other   |            | 0.06471    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5394.00 ave        5394 max        5394 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333986.0 ave      333986 max      333986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333986
Ave neighs/atom = 166.99300
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 = 272.817056802785, Press = -1.90218026698473
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -8039.8337   -8039.8337   -8108.2215   -8108.2215    264.66794    264.66794    21616.572    21616.572   -2267.9257   -2267.9257 
   53000   -8039.7464   -8039.7464   -8109.0189   -8109.0189    268.09149    268.09149    21609.935    21609.935   -3432.1341   -3432.1341 
Loop time of 33.1219 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.609 ns/day, 9.201 hours/ns, 30.191 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    | 32.543     | 32.543     | 32.543     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13013    | 0.13013    | 0.13013    |   0.0 |  0.39
Output  | 0.0001545  | 0.0001545  | 0.0001545  |   0.0 |  0.00
Modify  | 0.38461    | 0.38461    | 0.38461    |   0.0 |  1.16
Other   |            | 0.06429    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5410.00 ave        5410 max        5410 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332576.0 ave      332576 max      332576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332576
Ave neighs/atom = 166.28800
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 = 272.808747445248, Press = -1.47604363105876
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -8039.7464   -8039.7464   -8109.0189   -8109.0189    268.09149    268.09149    21609.935    21609.935   -3432.1341   -3432.1341 
   54000   -8038.8398   -8038.8398   -8110.1509   -8110.1509    275.98124    275.98124    21584.044    21584.044   -949.61425   -949.61425 
Loop time of 32.7903 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.635 ns/day, 9.108 hours/ns, 30.497 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.205     | 32.205     | 32.205     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13186    | 0.13186    | 0.13186    |   0.0 |  0.40
Output  | 0.00020041 | 0.00020041 | 0.00020041 |   0.0 |  0.00
Modify  | 0.38805    | 0.38805    | 0.38805    |   0.0 |  1.18
Other   |            | 0.06525    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5414.00 ave        5414 max        5414 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332514.0 ave      332514 max      332514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332514
Ave neighs/atom = 166.25700
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 = 272.826056155392, Press = -2.36019826884615
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -8038.8398   -8038.8398   -8110.1509   -8110.1509    275.98124    275.98124    21584.044    21584.044   -949.61425   -949.61425 
   55000   -8037.2806   -8037.2806   -8107.9342   -8107.9342    273.43654    273.43654    21578.007    21578.007    432.95179    432.95179 
Loop time of 32.0836 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.693 ns/day, 8.912 hours/ns, 31.169 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    | 31.517     | 31.517     | 31.517     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1275     | 0.1275     | 0.1275     |   0.0 |  0.40
Output  | 0.00015273 | 0.00015273 | 0.00015273 |   0.0 |  0.00
Modify  | 0.37449    | 0.37449    | 0.37449    |   0.0 |  1.17
Other   |            | 0.06486    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5406.00 ave        5406 max        5406 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333018.0 ave      333018 max      333018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333018
Ave neighs/atom = 166.50900
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 = 272.799350521428, Press = 0.0556945859833404
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -8037.2806   -8037.2806   -8107.9342   -8107.9342    273.43654    273.43654    21578.007    21578.007    432.95179    432.95179 
   56000   -8043.5593   -8043.5593   -8111.6597   -8111.6597     263.5554     263.5554    21543.178    21543.178    1388.5978    1388.5978 
Loop time of 32.2872 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.676 ns/day, 8.969 hours/ns, 30.972 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    | 31.718     | 31.718     | 31.718     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12832    | 0.12832    | 0.12832    |   0.0 |  0.40
Output  | 0.00015428 | 0.00015428 | 0.00015428 |   0.0 |  0.00
Modify  | 0.37645    | 0.37645    | 0.37645    |   0.0 |  1.17
Other   |            | 0.06401    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5426.00 ave        5426 max        5426 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333212.0 ave      333212 max      333212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333212
Ave neighs/atom = 166.60600
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 = 272.783578830395, Press = -0.285366824146232
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -8043.5593   -8043.5593   -8111.6597   -8111.6597     263.5554     263.5554    21543.178    21543.178    1388.5978    1388.5978 
   57000   -8039.2043   -8039.2043    -8109.611    -8109.611    272.48111    272.48111    21537.741    21537.741    1445.8279    1445.8279 
Loop time of 31.9661 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.703 ns/day, 8.879 hours/ns, 31.283 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    | 31.401     | 31.401     | 31.401     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12647    | 0.12647    | 0.12647    |   0.0 |  0.40
Output  | 0.00015542 | 0.00015542 | 0.00015542 |   0.0 |  0.00
Modify  | 0.37433    | 0.37433    | 0.37433    |   0.0 |  1.17
Other   |            | 0.06458    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5412.00 ave        5412 max        5412 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333732.0 ave      333732 max      333732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333732
Ave neighs/atom = 166.86600
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 = 272.748475350039, Press = -1.01240279383398
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -8039.2043   -8039.2043    -8109.611    -8109.611    272.48111    272.48111    21537.741    21537.741    1445.8279    1445.8279 
   58000   -8036.4544   -8036.4544   -8107.5823   -8107.5823    275.27226    275.27226    21576.851    21576.851   -214.82526   -214.82526 
Loop time of 31.5896 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.735 ns/day, 8.775 hours/ns, 31.656 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    | 31.032     | 31.032     | 31.032     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12571    | 0.12571    | 0.12571    |   0.0 |  0.40
Output  | 0.00019338 | 0.00019338 | 0.00019338 |   0.0 |  0.00
Modify  | 0.36765    | 0.36765    | 0.36765    |   0.0 |  1.16
Other   |            | 0.06416    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5421.00 ave        5421 max        5421 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333704.0 ave      333704 max      333704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333704
Ave neighs/atom = 166.85200
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 = 272.72975868297, Press = -1.06795246472549
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -8036.4544   -8036.4544   -8107.5823   -8107.5823    275.27226    275.27226    21576.851    21576.851   -214.82526   -214.82526 
   59000   -8041.5207   -8041.5207   -8110.7194   -8110.7194    267.80605    267.80605     21585.99     21585.99   -2626.2421   -2626.2421 
Loop time of 32.9677 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.621 ns/day, 9.158 hours/ns, 30.333 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.388     | 32.388     | 32.388     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13013    | 0.13013    | 0.13013    |   0.0 |  0.39
Output  | 0.00020085 | 0.00020085 | 0.00020085 |   0.0 |  0.00
Modify  | 0.38486    | 0.38486    | 0.38486    |   0.0 |  1.17
Other   |            | 0.06481    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5433.00 ave        5433 max        5433 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333352.0 ave      333352 max      333352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333352
Ave neighs/atom = 166.67600
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 = 272.735625118032, Press = 0.441582281197642
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -8041.5207   -8041.5207   -8110.7194   -8110.7194    267.80605    267.80605     21585.99     21585.99   -2626.2421   -2626.2421 
   60000   -8037.4442   -8037.4442    -8108.921    -8108.921     276.6227     276.6227    21577.567    21577.567   -1400.8908   -1400.8908 
Loop time of 33.4669 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.582 ns/day, 9.296 hours/ns, 29.880 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.875     | 32.875     | 32.875     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13136    | 0.13136    | 0.13136    |   0.0 |  0.39
Output  | 0.00015314 | 0.00015314 | 0.00015314 |   0.0 |  0.00
Modify  | 0.3942     | 0.3942     | 0.3942     |   0.0 |  1.18
Other   |            | 0.06579    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5416.00 ave        5416 max        5416 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333070.0 ave      333070 max      333070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333070
Ave neighs/atom = 166.53500
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 = 272.694375381682, Press = -0.665666316698059
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -8037.4442   -8037.4442    -8108.921    -8108.921     276.6227     276.6227    21577.567    21577.567   -1400.8908   -1400.8908 
   61000   -8038.0625   -8038.0625    -8110.074    -8110.074    278.69179    278.69179    21562.463    21562.463    -1146.499    -1146.499 
Loop time of 32.8968 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.626 ns/day, 9.138 hours/ns, 30.398 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    | 32.32      | 32.32      | 32.32      |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12928    | 0.12928    | 0.12928    |   0.0 |  0.39
Output  | 0.00015383 | 0.00015383 | 0.00015383 |   0.0 |  0.00
Modify  | 0.38217    | 0.38217    | 0.38217    |   0.0 |  1.16
Other   |            | 0.06507    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5400.00 ave        5400 max        5400 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333236.0 ave      333236 max      333236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333236
Ave neighs/atom = 166.61800
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 = 272.696677161292, Press = 0.00672662380398872
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -8038.0625   -8038.0625    -8110.074    -8110.074    278.69179    278.69179    21562.463    21562.463    -1146.499    -1146.499 
   62000   -8041.4659   -8041.4659   -8110.6618   -8110.6618    267.79532    267.79532    21569.515    21569.515    -828.2879    -828.2879 
Loop time of 31.842 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.713 ns/day, 8.845 hours/ns, 31.405 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    | 31.28      | 31.28      | 31.28      |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12737    | 0.12737    | 0.12737    |   0.0 |  0.40
Output  | 0.00015355 | 0.00015355 | 0.00015355 |   0.0 |  0.00
Modify  | 0.37072    | 0.37072    | 0.37072    |   0.0 |  1.16
Other   |            | 0.06399    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5405.00 ave        5405 max        5405 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333384.0 ave      333384 max      333384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333384
Ave neighs/atom = 166.69200
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 = 272.707070875191, Press = -1.2194848282998
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -8041.4659   -8041.4659   -8110.6618   -8110.6618    267.79532    267.79532    21569.515    21569.515    -828.2879    -828.2879 
   63000   -8040.1855   -8040.1855   -8109.3469   -8109.3469    267.66187    267.66187    21542.232    21542.232    2080.6464    2080.6464 
Loop time of 32.4412 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.663 ns/day, 9.011 hours/ns, 30.825 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    | 31.874     | 31.874     | 31.874     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12824    | 0.12824    | 0.12824    |   0.0 |  0.40
Output  | 0.000153   | 0.000153   | 0.000153   |   0.0 |  0.00
Modify  | 0.37507    | 0.37507    | 0.37507    |   0.0 |  1.16
Other   |            | 0.06408    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5402.00 ave        5402 max        5402 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333486.0 ave      333486 max      333486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333486
Ave neighs/atom = 166.74300
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 = 272.701923153034, Press = -1.25239740416503
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -8040.1855   -8040.1855   -8109.3469   -8109.3469    267.66187    267.66187    21542.232    21542.232    2080.6464    2080.6464 
   64000   -8037.1076   -8037.1076    -8108.227    -8108.227    275.23953    275.23953    21570.715    21570.715   0.60499292   0.60499292 
Loop time of 32.3841 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.668 ns/day, 8.996 hours/ns, 30.879 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    | 31.814     | 31.814     | 31.814     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12877    | 0.12877    | 0.12877    |   0.0 |  0.40
Output  | 0.0001558  | 0.0001558  | 0.0001558  |   0.0 |  0.00
Modify  | 0.37661    | 0.37661    | 0.37661    |   0.0 |  1.16
Other   |            | 0.06407    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5402.00 ave        5402 max        5402 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333748.0 ave      333748 max      333748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333748
Ave neighs/atom = 166.87400
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 = 272.719688425811, Press = -0.0178442692101052
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -8037.1076   -8037.1076    -8108.227    -8108.227    275.23953    275.23953    21570.715    21570.715   0.60499292   0.60499292 
   65000   -8038.8156   -8038.8156   -8109.8441   -8109.8441    274.88763    274.88763    21562.644    21562.644    521.84809    521.84809 
Loop time of 32.4984 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.659 ns/day, 9.027 hours/ns, 30.771 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    | 31.919     | 31.919     | 31.919     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1296     | 0.1296     | 0.1296     |   0.0 |  0.40
Output  | 0.00015325 | 0.00015325 | 0.00015325 |   0.0 |  0.00
Modify  | 0.38461    | 0.38461    | 0.38461    |   0.0 |  1.18
Other   |            | 0.06511    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5415.00 ave        5415 max        5415 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333344.0 ave      333344 max      333344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333344
Ave neighs/atom = 166.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 = 272.720452973607, Press = 0.721869461722665
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -8038.8156   -8038.8156   -8109.8441   -8109.8441    274.88763    274.88763    21562.644    21562.644    521.84809    521.84809 
   66000   -8037.1137   -8037.1137   -8110.7537   -8110.7537    284.99445    284.99445    21497.289    21497.289    3787.1578    3787.1578 
Loop time of 32.0243 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.698 ns/day, 8.896 hours/ns, 31.226 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    | 31.455     | 31.455     | 31.455     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1289     | 0.1289     | 0.1289     |   0.0 |  0.40
Output  | 0.00019622 | 0.00019622 | 0.00019622 |   0.0 |  0.00
Modify  | 0.37556    | 0.37556    | 0.37556    |   0.0 |  1.17
Other   |            | 0.06457    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5409.00 ave        5409 max        5409 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333456.0 ave      333456 max      333456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333456
Ave neighs/atom = 166.72800
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 = 272.741489596725, Press = 0.197392808156942
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -8037.1137   -8037.1137   -8110.7537   -8110.7537    284.99445    284.99445    21497.289    21497.289    3787.1578    3787.1578 
   67000   -8041.8154   -8041.8154   -8109.3162   -8109.3162    261.23536    261.23536    21572.946    21572.946    497.42181    497.42181 
Loop time of 32.5572 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.654 ns/day, 9.044 hours/ns, 30.715 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    | 31.979     | 31.979     | 31.979     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12936    | 0.12936    | 0.12936    |   0.0 |  0.40
Output  | 0.00015435 | 0.00015435 | 0.00015435 |   0.0 |  0.00
Modify  | 0.38363    | 0.38363    | 0.38363    |   0.0 |  1.18
Other   |            | 0.06485    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5425.00 ave        5425 max        5425 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      334250.0 ave      334250 max      334250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334250
Ave neighs/atom = 167.12500
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 = 272.754297309936, Press = -1.05666352703906
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -8041.8154   -8041.8154   -8109.3162   -8109.3162    261.23536    261.23536    21572.946    21572.946    497.42181    497.42181 
   68000   -8036.9912   -8036.9912   -8109.5929   -8109.5929    280.97619    280.97619    21548.145    21548.145    412.09672    412.09672 
Loop time of 31.1355 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.775 ns/day, 8.649 hours/ns, 32.118 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    | 30.583     | 30.583     | 30.583     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12479    | 0.12479    | 0.12479    |   0.0 |  0.40
Output  | 0.00015459 | 0.00015459 | 0.00015459 |   0.0 |  0.00
Modify  | 0.36403    | 0.36403    | 0.36403    |   0.0 |  1.17
Other   |            | 0.06369    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5423.00 ave        5423 max        5423 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333260.0 ave      333260 max      333260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333260
Ave neighs/atom = 166.63000
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 = 272.764171480332, Press = -1.42857132563018
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -8036.9912   -8036.9912   -8109.5929   -8109.5929    280.97619    280.97619    21548.145    21548.145    412.09672    412.09672 
   69000    -8038.854    -8038.854    -8110.499    -8110.499    277.27372    277.27372    21555.262    21555.262    997.11137    997.11137 
Loop time of 32.1439 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.688 ns/day, 8.929 hours/ns, 31.110 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    | 31.574     | 31.574     | 31.574     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12788    | 0.12788    | 0.12788    |   0.0 |  0.40
Output  | 0.00015536 | 0.00015536 | 0.00015536 |   0.0 |  0.00
Modify  | 0.37738    | 0.37738    | 0.37738    |   0.0 |  1.17
Other   |            | 0.06401    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5419.00 ave        5419 max        5419 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333958.0 ave      333958 max      333958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333958
Ave neighs/atom = 166.97900
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 = 272.767087992817, Press = -1.04549751882432
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000    -8038.854    -8038.854    -8110.499    -8110.499    277.27372    277.27372    21555.262    21555.262    997.11137    997.11137 
   70000   -8040.8281   -8040.8281   -8109.9124   -8109.9124     267.3635     267.3635    21550.543    21550.543    364.10914    364.10914 
Loop time of 31.6187 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.733 ns/day, 8.783 hours/ns, 31.627 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    | 31.059     | 31.059     | 31.059     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1266     | 0.1266     | 0.1266     |   0.0 |  0.40
Output  | 0.00015114 | 0.00015114 | 0.00015114 |   0.0 |  0.00
Modify  | 0.3691     | 0.3691     | 0.3691     |   0.0 |  1.17
Other   |            | 0.06429    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5403.00 ave        5403 max        5403 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333594.0 ave      333594 max      333594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333594
Ave neighs/atom = 166.79700
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 = 272.778957065469, Press = -1.34545982705722
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -8040.8281   -8040.8281   -8109.9124   -8109.9124     267.3635     267.3635    21550.543    21550.543    364.10914    364.10914 
   71000   -8038.7545   -8038.7545   -8108.4968   -8108.4968    269.90995    269.90995    21587.605    21587.605   -348.14767   -348.14767 
Loop time of 31.1992 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.769 ns/day, 8.666 hours/ns, 32.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    | 30.647     | 30.647     | 30.647     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12526    | 0.12526    | 0.12526    |   0.0 |  0.40
Output  | 0.00015229 | 0.00015229 | 0.00015229 |   0.0 |  0.00
Modify  | 0.3631     | 0.3631     | 0.3631     |   0.0 |  1.16
Other   |            | 0.06375    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5403.00 ave        5403 max        5403 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333488.0 ave      333488 max      333488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333488
Ave neighs/atom = 166.74400
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 = 272.786455383821, Press = -1.34726271319846
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -8038.7545   -8038.7545   -8108.4968   -8108.4968    269.90995    269.90995    21587.605    21587.605   -348.14767   -348.14767 
   72000   -8037.8688   -8037.8688   -8108.4117   -8108.4117    273.00827    273.00827    21616.281    21616.281   -2879.4543   -2879.4543 
Loop time of 32.6189 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.649 ns/day, 9.061 hours/ns, 30.657 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    | 32.044     | 32.044     | 32.044     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12831    | 0.12831    | 0.12831    |   0.0 |  0.39
Output  | 0.00015677 | 0.00015677 | 0.00015677 |   0.0 |  0.00
Modify  | 0.38179    | 0.38179    | 0.38179    |   0.0 |  1.17
Other   |            | 0.06509    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5405.00 ave        5405 max        5405 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333074.0 ave      333074 max      333074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333074
Ave neighs/atom = 166.53700
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 = 272.798001572138, Press = -0.606540505790368
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -8037.8688   -8037.8688   -8108.4117   -8108.4117    273.00827    273.00827    21616.281    21616.281   -2879.4543   -2879.4543 
   73000   -8039.4661   -8039.4661   -8111.5082   -8111.5082    278.81069    278.81069    21544.382    21544.382   -709.37215   -709.37215 
Loop time of 32.0493 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.696 ns/day, 8.903 hours/ns, 31.202 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    | 31.484     | 31.484     | 31.484     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12791    | 0.12791    | 0.12791    |   0.0 |  0.40
Output  | 0.00014865 | 0.00014865 | 0.00014865 |   0.0 |  0.00
Modify  | 0.37365    | 0.37365    | 0.37365    |   0.0 |  1.17
Other   |            | 0.06397    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5412.00 ave        5412 max        5412 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332296.0 ave      332296 max      332296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332296
Ave neighs/atom = 166.14800
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 = 272.824667050197, Press = -0.597459028763336
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -8039.4661   -8039.4661   -8111.5082   -8111.5082    278.81069    278.81069    21544.382    21544.382   -709.37215   -709.37215 
   74000   -8038.9623   -8038.9623   -8107.7854   -8107.7854    266.35239    266.35239     21597.37     21597.37    -1851.676    -1851.676 
Loop time of 32.6011 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.650 ns/day, 9.056 hours/ns, 30.674 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    | 32.026     | 32.026     | 32.026     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12842    | 0.12842    | 0.12842    |   0.0 |  0.39
Output  | 0.0001556  | 0.0001556  | 0.0001556  |   0.0 |  0.00
Modify  | 0.38222    | 0.38222    | 0.38222    |   0.0 |  1.17
Other   |            | 0.0646     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5415.00 ave        5415 max        5415 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333570.0 ave      333570 max      333570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333570
Ave neighs/atom = 166.78500
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 = 272.798103549291, Press = -0.0826586816218225
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -8038.9623   -8038.9623   -8107.7854   -8107.7854    266.35239    266.35239     21597.37     21597.37    -1851.676    -1851.676 
   75000   -8040.2113   -8040.2113   -8111.0326   -8111.0326     274.0858     274.0858    21562.243    21562.243    250.22269    250.22269 
Loop time of 31.7838 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.718 ns/day, 8.829 hours/ns, 31.463 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    | 31.219     | 31.219     | 31.219     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12642    | 0.12642    | 0.12642    |   0.0 |  0.40
Output  | 0.00019661 | 0.00019661 | 0.00019661 |   0.0 |  0.00
Modify  | 0.37328    | 0.37328    | 0.37328    |   0.0 |  1.17
Other   |            | 0.06518    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5422.00 ave        5422 max        5422 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332964.0 ave      332964 max      332964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332964
Ave neighs/atom = 166.48200
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 = 272.797127695827, Press = -1.06221740648694
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -8040.2113   -8040.2113   -8111.0326   -8111.0326     274.0858     274.0858    21562.243    21562.243    250.22269    250.22269 
   76000   -8038.3487   -8038.3487   -8110.1628   -8110.1628    277.92822    277.92822    21593.129    21593.129   -1215.0364   -1215.0364 
Loop time of 31.5794 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.736 ns/day, 8.772 hours/ns, 31.666 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    | 31.02      | 31.02      | 31.02      |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12553    | 0.12553    | 0.12553    |   0.0 |  0.40
Output  | 0.00015601 | 0.00015601 | 0.00015601 |   0.0 |  0.00
Modify  | 0.36964    | 0.36964    | 0.36964    |   0.0 |  1.17
Other   |            | 0.06429    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5412.00 ave        5412 max        5412 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333582.0 ave      333582 max      333582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333582
Ave neighs/atom = 166.79100
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 = 272.779498176002, Press = -0.960968970471411
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -8038.3487   -8038.3487   -8110.1628   -8110.1628    277.92822    277.92822    21593.129    21593.129   -1215.0364   -1215.0364 
   77000   -8035.6865   -8035.6865   -8108.2481   -8108.2481    280.82122    280.82122    21550.415    21550.415    1002.1155    1002.1155 
Loop time of 31.8763 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.710 ns/day, 8.855 hours/ns, 31.371 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    | 31.311     | 31.311     | 31.311     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12705    | 0.12705    | 0.12705    |   0.0 |  0.40
Output  | 0.00019202 | 0.00019202 | 0.00019202 |   0.0 |  0.00
Modify  | 0.37328    | 0.37328    | 0.37328    |   0.0 |  1.17
Other   |            | 0.0644     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5404.00 ave        5404 max        5404 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332784.0 ave      332784 max      332784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332784
Ave neighs/atom = 166.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 = 272.793769341946, Press = -1.39072217733376
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -8035.6865   -8035.6865   -8108.2481   -8108.2481    280.82122    280.82122    21550.415    21550.415    1002.1155    1002.1155 
   78000    -8038.942    -8038.942   -8110.3363   -8110.3363    276.30334    276.30334    21595.308    21595.308   -2869.6044   -2869.6044 
Loop time of 31.7064 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.725 ns/day, 8.807 hours/ns, 31.539 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.145     | 31.145     | 31.145     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12603    | 0.12603    | 0.12603    |   0.0 |  0.40
Output  | 0.00015302 | 0.00015302 | 0.00015302 |   0.0 |  0.00
Modify  | 0.36996    | 0.36996    | 0.36996    |   0.0 |  1.17
Other   |            | 0.06507    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5425.00 ave        5425 max        5425 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333650.0 ave      333650 max      333650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333650
Ave neighs/atom = 166.82500
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 = 272.829778431398, Press = -2.0576060455381
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000    -8038.942    -8038.942   -8110.3363   -8110.3363    276.30334    276.30334    21595.308    21595.308   -2869.6044   -2869.6044 
   79000   -8036.1959   -8036.1959   -8107.9663   -8107.9663    277.75888    277.75888    21571.828    21571.828   -18.400698   -18.400698 
Loop time of 32.5588 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.654 ns/day, 9.044 hours/ns, 30.714 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.984     | 31.984     | 31.984     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13019    | 0.13019    | 0.13019    |   0.0 |  0.40
Output  | 0.00014893 | 0.00014893 | 0.00014893 |   0.0 |  0.00
Modify  | 0.37966    | 0.37966    | 0.37966    |   0.0 |  1.17
Other   |            | 0.0652     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5416.00 ave        5416 max        5416 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332774.0 ave      332774 max      332774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332774
Ave neighs/atom = 166.38700
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 = 272.852766876708, Press = -0.955667425100534
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -8036.1959   -8036.1959   -8107.9663   -8107.9663    277.75888    277.75888    21571.828    21571.828   -18.400698   -18.400698 
   80000   -8040.9842   -8040.9842   -8109.8876   -8109.8876    266.66319    266.66319    21516.914    21516.914    3603.0221    3603.0221 
Loop time of 31.7943 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.717 ns/day, 8.832 hours/ns, 31.452 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    | 31.232     | 31.232     | 31.232     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12709    | 0.12709    | 0.12709    |   0.0 |  0.40
Output  | 0.00015842 | 0.00015842 | 0.00015842 |   0.0 |  0.00
Modify  | 0.37127    | 0.37127    | 0.37127    |   0.0 |  1.17
Other   |            | 0.06401    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5414.00 ave        5414 max        5414 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333178.0 ave      333178 max      333178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333178
Ave neighs/atom = 166.58900
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 = 272.852382570373, Press = -0.626694690302077
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000   -8040.9842   -8040.9842   -8109.8876   -8109.8876    266.66319    266.66319    21516.914    21516.914    3603.0221    3603.0221 
   81000    -8037.063    -8037.063   -8109.5263   -8109.5263    280.44023    280.44023    21543.277    21543.277    1010.8448    1010.8448 
Loop time of 32.6885 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.643 ns/day, 9.080 hours/ns, 30.592 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.109     | 32.109     | 32.109     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13042    | 0.13042    | 0.13042    |   0.0 |  0.40
Output  | 0.00020078 | 0.00020078 | 0.00020078 |   0.0 |  0.00
Modify  | 0.38308    | 0.38308    | 0.38308    |   0.0 |  1.17
Other   |            | 0.06532    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5421.00 ave        5421 max        5421 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      334190.0 ave      334190 max      334190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334190
Ave neighs/atom = 167.09500
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 = 272.838879403783, Press = -1.32942150366226
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000    -8037.063    -8037.063   -8109.5263   -8109.5263    280.44023    280.44023    21543.277    21543.277    1010.8448    1010.8448 
   82000   -8042.1328   -8042.1328   -8109.7066   -8109.7066     261.5173     261.5173    21563.127    21563.127    103.98486    103.98486 
Loop time of 31.4049 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.751 ns/day, 8.724 hours/ns, 31.842 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    | 30.847     | 30.847     | 30.847     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12609    | 0.12609    | 0.12609    |   0.0 |  0.40
Output  | 0.00044867 | 0.00044867 | 0.00044867 |   0.0 |  0.00
Modify  | 0.36646    | 0.36646    | 0.36646    |   0.0 |  1.17
Other   |            | 0.06471    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5421.00 ave        5421 max        5421 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333744.0 ave      333744 max      333744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333744
Ave neighs/atom = 166.87200
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 = 272.820140342484, Press = -0.967329383834554
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000   -8042.1328   -8042.1328   -8109.7066   -8109.7066     261.5173     261.5173    21563.127    21563.127    103.98486    103.98486 
   83000   -8036.3338   -8036.3338   -8109.4033   -8109.4033     282.7866     282.7866    21572.975    21572.975    457.54925    457.54925 
Loop time of 31.4285 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.749 ns/day, 8.730 hours/ns, 31.818 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    | 30.871     | 30.871     | 30.871     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12652    | 0.12652    | 0.12652    |   0.0 |  0.40
Output  | 0.00015433 | 0.00015433 | 0.00015433 |   0.0 |  0.00
Modify  | 0.36702    | 0.36702    | 0.36702    |   0.0 |  1.17
Other   |            | 0.06393    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5407.00 ave        5407 max        5407 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333344.0 ave      333344 max      333344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333344
Ave neighs/atom = 166.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 = 272.797058598135, Press = -1.6452524309049
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -8036.3338   -8036.3338   -8109.4033   -8109.4033     282.7866     282.7866    21572.975    21572.975    457.54925    457.54925 
   84000   -8040.1401   -8040.1401   -8108.9019   -8108.9019    266.11536    266.11536    21605.956    21605.956   -1289.7323   -1289.7323 
Loop time of 32.2021 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.683 ns/day, 8.945 hours/ns, 31.054 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.634     | 31.634     | 31.634     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12717    | 0.12717    | 0.12717    |   0.0 |  0.39
Output  | 0.00015359 | 0.00015359 | 0.00015359 |   0.0 |  0.00
Modify  | 0.37678    | 0.37678    | 0.37678    |   0.0 |  1.17
Other   |            | 0.06391    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5403.00 ave        5403 max        5403 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333298.0 ave      333298 max      333298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333298
Ave neighs/atom = 166.64900
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 = 272.788888047063, Press = 0.0404003275594395
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -8040.1401   -8040.1401   -8108.9019   -8108.9019    266.11536    266.11536    21605.956    21605.956   -1289.7323   -1289.7323 
   85000   -8039.9823   -8039.9823   -8111.2767   -8111.2767    275.91646    275.91646    21532.845    21532.845    2330.1974    2330.1974 
Loop time of 31.5972 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.734 ns/day, 8.777 hours/ns, 31.648 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    | 31.038     | 31.038     | 31.038     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12599    | 0.12599    | 0.12599    |   0.0 |  0.40
Output  | 0.0001501  | 0.0001501  | 0.0001501  |   0.0 |  0.00
Modify  | 0.3691     | 0.3691     | 0.3691     |   0.0 |  1.17
Other   |            | 0.06379    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5416.00 ave        5416 max        5416 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332818.0 ave      332818 max      332818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332818
Ave neighs/atom = 166.40900
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 = 272.790624130301, Press = -0.48650489697627
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -8039.9823   -8039.9823   -8111.2767   -8111.2767    275.91646    275.91646    21532.845    21532.845    2330.1974    2330.1974 
   86000   -8036.0855   -8036.0855   -8107.1957   -8107.1957    275.20385    275.20385    21560.473    21560.473     542.2954     542.2954 
Loop time of 31.7339 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.723 ns/day, 8.815 hours/ns, 31.512 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    | 31.165     | 31.165     | 31.165     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12713    | 0.12713    | 0.12713    |   0.0 |  0.40
Output  | 0.00020019 | 0.00020019 | 0.00020019 |   0.0 |  0.00
Modify  | 0.37631    | 0.37631    | 0.37631    |   0.0 |  1.19
Other   |            | 0.06482    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5411.00 ave        5411 max        5411 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333842.0 ave      333842 max      333842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333842
Ave neighs/atom = 166.92100
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 = 272.802915468491, Press = -0.323545516903438
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -8036.0855   -8036.0855   -8107.1957   -8107.1957    275.20385    275.20385    21560.473    21560.473     542.2954     542.2954 
   87000   -8040.1769   -8040.1769   -8109.3705   -8109.3705    267.78625    267.78625    21595.727    21595.727    -829.6481    -829.6481 
Loop time of 32.3293 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.672 ns/day, 8.980 hours/ns, 30.932 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    | 31.76      | 31.76      | 31.76      |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12728    | 0.12728    | 0.12728    |   0.0 |  0.39
Output  | 0.00020332 | 0.00020332 | 0.00020332 |   0.0 |  0.00
Modify  | 0.3766     | 0.3766     | 0.3766     |   0.0 |  1.16
Other   |            | 0.06482    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5414.00 ave        5414 max        5414 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333638.0 ave      333638 max      333638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333638
Ave neighs/atom = 166.81900
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 = 272.824328331915, Press = -1.37460630683584
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -8040.1769   -8040.1769   -8109.3705   -8109.3705    267.78625    267.78625    21595.727    21595.727    -829.6481    -829.6481 
   88000   -8039.5531   -8039.5531    -8109.473    -8109.473    270.59734    270.59734    21587.207    21587.207   -1498.2698   -1498.2698 
Loop time of 32.0156 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.699 ns/day, 8.893 hours/ns, 31.235 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    | 31.453     | 31.453     | 31.453     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12699    | 0.12699    | 0.12699    |   0.0 |  0.40
Output  | 0.0001536  | 0.0001536  | 0.0001536  |   0.0 |  0.00
Modify  | 0.37102    | 0.37102    | 0.37102    |   0.0 |  1.16
Other   |            | 0.06462    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5410.00 ave        5410 max        5410 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332796.0 ave      332796 max      332796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332796
Ave neighs/atom = 166.39800
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 = 272.8299851985, Press = -0.997507089064242
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000   -8039.5531   -8039.5531    -8109.473    -8109.473    270.59734    270.59734    21587.207    21587.207   -1498.2698   -1498.2698 
   89000   -8039.0059   -8039.0059   -8109.3592   -8109.3592     272.2745     272.2745    21589.329    21589.329   -1333.3512   -1333.3512 
Loop time of 31.6958 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.726 ns/day, 8.804 hours/ns, 31.550 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    | 31.135     | 31.135     | 31.135     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12573    | 0.12573    | 0.12573    |   0.0 |  0.40
Output  | 0.00015233 | 0.00015233 | 0.00015233 |   0.0 |  0.00
Modify  | 0.37088    | 0.37088    | 0.37088    |   0.0 |  1.17
Other   |            | 0.0639     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5399.00 ave        5399 max        5399 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333198.0 ave      333198 max      333198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333198
Ave neighs/atom = 166.59900
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 = 272.804319947282, Press = -0.51020183316793
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -8039.0059   -8039.0059   -8109.3592   -8109.3592     272.2745     272.2745    21589.329    21589.329   -1333.3512   -1333.3512 
   90000   -8040.8862   -8040.8862   -8109.1375   -8109.1375    264.13945    264.13945    21549.663    21549.663    1350.8613    1350.8613 
Loop time of 31.567 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.737 ns/day, 8.769 hours/ns, 31.679 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    | 31.008     | 31.008     | 31.008     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12762    | 0.12762    | 0.12762    |   0.0 |  0.40
Output  | 0.00020099 | 0.00020099 | 0.00020099 |   0.0 |  0.00
Modify  | 0.3671     | 0.3671     | 0.3671     |   0.0 |  1.16
Other   |            | 0.06416    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5430.00 ave        5430 max        5430 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332690.0 ave      332690 max      332690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332690
Ave neighs/atom = 166.34500
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 = 272.79500251627, Press = -0.631349612016285
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -8040.8862   -8040.8862   -8109.1375   -8109.1375    264.13945    264.13945    21549.663    21549.663    1350.8613    1350.8613 
   91000   -8036.6818   -8036.6818   -8107.0054   -8107.0054    272.15968    272.15968    21574.346    21574.346    816.32298    816.32298 
Loop time of 32.9267 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.624 ns/day, 9.146 hours/ns, 30.370 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    | 32.349     | 32.349     | 32.349     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13038    | 0.13038    | 0.13038    |   0.0 |  0.40
Output  | 0.00019558 | 0.00019558 | 0.00019558 |   0.0 |  0.00
Modify  | 0.38158    | 0.38158    | 0.38158    |   0.0 |  1.16
Other   |            | 0.06513    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5417.00 ave        5417 max        5417 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333674.0 ave      333674 max      333674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333674
Ave neighs/atom = 166.83700
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 = 272.780377435665, Press = -0.718725471599583
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000   -8036.6818   -8036.6818   -8107.0054   -8107.0054    272.15968    272.15968    21574.346    21574.346    816.32298    816.32298 
   92000   -8038.0364   -8038.0364   -8111.4152   -8111.4152     283.9838     283.9838    21510.543    21510.543    3467.3508    3467.3508 
Loop time of 31.3936 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.752 ns/day, 8.720 hours/ns, 31.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    | 30.836     | 30.836     | 30.836     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12552    | 0.12552    | 0.12552    |   0.0 |  0.40
Output  | 0.00015372 | 0.00015372 | 0.00015372 |   0.0 |  0.00
Modify  | 0.36711    | 0.36711    | 0.36711    |   0.0 |  1.17
Other   |            | 0.06445    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5421.00 ave        5421 max        5421 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333416.0 ave      333416 max      333416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333416
Ave neighs/atom = 166.70800
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 = 272.78784588432, Press = -1.36537535105417
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000   -8038.0364   -8038.0364   -8111.4152   -8111.4152     283.9838     283.9838    21510.543    21510.543    3467.3508    3467.3508 
   93000   -8037.6818   -8037.6818    -8108.007    -8108.007    272.16598    272.16598    21606.475    21606.475   -1674.1417   -1674.1417 
Loop time of 31.6026 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.734 ns/day, 8.778 hours/ns, 31.643 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    | 31.046     | 31.046     | 31.046     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12574    | 0.12574    | 0.12574    |   0.0 |  0.40
Output  | 0.00015682 | 0.00015682 | 0.00015682 |   0.0 |  0.00
Modify  | 0.36715    | 0.36715    | 0.36715    |   0.0 |  1.16
Other   |            | 0.06387    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5422.00 ave        5422 max        5422 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      334120.0 ave      334120 max      334120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334120
Ave neighs/atom = 167.06000
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 = 272.823812415956, Press = -0.960479549871988
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000   -8037.6818   -8037.6818    -8108.007    -8108.007    272.16598    272.16598    21606.475    21606.475   -1674.1417   -1674.1417 
   94000   -8041.2483   -8041.2483    -8110.191    -8110.191    266.81556    266.81556    21556.201    21556.201    403.73936    403.73936 
Loop time of 31.5506 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.738 ns/day, 8.764 hours/ns, 31.695 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    | 30.991     | 30.991     | 30.991     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12608    | 0.12608    | 0.12608    |   0.0 |  0.40
Output  | 0.00015721 | 0.00015721 | 0.00015721 |   0.0 |  0.00
Modify  | 0.36866    | 0.36866    | 0.36866    |   0.0 |  1.17
Other   |            | 0.06435    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5409.00 ave        5409 max        5409 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332604.0 ave      332604 max      332604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332604
Ave neighs/atom = 166.30200
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 = 272.811913631715, Press = 0.177089690134484
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000   -8041.2483   -8041.2483    -8110.191    -8110.191    266.81556    266.81556    21556.201    21556.201    403.73936    403.73936 
   95000   -8038.7864   -8038.7864   -8109.0405   -8109.0405    271.89063    271.89063    21555.528    21555.528    83.608924    83.608924 
Loop time of 32.296 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.675 ns/day, 8.971 hours/ns, 30.964 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.725     | 31.725     | 31.725     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12749    | 0.12749    | 0.12749    |   0.0 |  0.39
Output  | 0.00015147 | 0.00015147 | 0.00015147 |   0.0 |  0.00
Modify  | 0.37913    | 0.37913    | 0.37913    |   0.0 |  1.17
Other   |            | 0.06452    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5424.00 ave        5424 max        5424 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333482.0 ave      333482 max      333482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333482
Ave neighs/atom = 166.74100
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 = 272.817459514374, Press = -0.660111208177649
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000   -8038.7864   -8038.7864   -8109.0405   -8109.0405    271.89063    271.89063    21555.528    21555.528    83.608924    83.608924 
   96000   -8037.4307   -8037.4307   -8107.3855   -8107.3855    270.73232    270.73232     21589.11     21589.11   -542.83491   -542.83491 
Loop time of 31.2064 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.769 ns/day, 8.668 hours/ns, 32.045 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    | 30.65      | 30.65      | 30.65      |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12531    | 0.12531    | 0.12531    |   0.0 |  0.40
Output  | 0.00020114 | 0.00020114 | 0.00020114 |   0.0 |  0.00
Modify  | 0.36638    | 0.36638    | 0.36638    |   0.0 |  1.17
Other   |            | 0.06431    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5420.00 ave        5420 max        5420 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333586.0 ave      333586 max      333586 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333586
Ave neighs/atom = 166.79300
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 = 272.820115775162, Press = -1.57592870744603
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000   -8037.4307   -8037.4307   -8107.3855   -8107.3855    270.73232    270.73232     21589.11     21589.11   -542.83491   -542.83491 
   97000   -8039.9481   -8039.9481    -8109.695    -8109.695    269.92777    269.92777    21577.514    21577.514   -715.75244   -715.75244 
Loop time of 31.3624 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.755 ns/day, 8.712 hours/ns, 31.885 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    | 30.805     | 30.805     | 30.805     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12544    | 0.12544    | 0.12544    |   0.0 |  0.40
Output  | 0.00015504 | 0.00015504 | 0.00015504 |   0.0 |  0.00
Modify  | 0.36741    | 0.36741    | 0.36741    |   0.0 |  1.17
Other   |            | 0.06412    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5397.00 ave        5397 max        5397 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332966.0 ave      332966 max      332966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332966
Ave neighs/atom = 166.48300
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 = 272.824398393007, Press = -0.231576542153008
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   97000   -8039.9481   -8039.9481    -8109.695    -8109.695    269.92777    269.92777    21577.514    21577.514   -715.75244   -715.75244 
   98000   -8036.0047   -8036.0047    -8107.553    -8107.553    276.89911    276.89911    21594.582    21594.582    -706.4459    -706.4459 
Loop time of 31.4701 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.745 ns/day, 8.742 hours/ns, 31.776 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    | 30.913     | 30.913     | 30.913     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12479    | 0.12479    | 0.12479    |   0.0 |  0.40
Output  | 0.00015482 | 0.00015482 | 0.00015482 |   0.0 |  0.00
Modify  | 0.36849    | 0.36849    | 0.36849    |   0.0 |  1.17
Other   |            | 0.06376    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5405.00 ave        5405 max        5405 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333278.0 ave      333278 max      333278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333278
Ave neighs/atom = 166.63900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.837746587978, Press = -0.722851866461115
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   98000   -8036.0047   -8036.0047    -8107.553    -8107.553    276.89911    276.89911    21594.582    21594.582    -706.4459    -706.4459 
   99000   -8039.3259   -8039.3259   -8110.4054   -8110.4054    275.08506    275.08506    21598.817    21598.817   -2370.5643   -2370.5643 
Loop time of 32.3511 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.671 ns/day, 8.986 hours/ns, 30.911 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    | 31.783     | 31.783     | 31.783     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12784    | 0.12784    | 0.12784    |   0.0 |  0.40
Output  | 0.00020365 | 0.00020365 | 0.00020365 |   0.0 |  0.00
Modify  | 0.37526    | 0.37526    | 0.37526    |   0.0 |  1.16
Other   |            | 0.06446    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5418.00 ave        5418 max        5418 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333056.0 ave      333056 max      333056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333056
Ave neighs/atom = 166.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 = 272.857841419202, Press = -0.541525019018967
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   99000   -8039.3259   -8039.3259   -8110.4054   -8110.4054    275.08506    275.08506    21598.817    21598.817   -2370.5643   -2370.5643 
  100000   -8032.9189   -8032.9189   -8106.1284   -8106.1284    283.32856    283.32856    21561.528    21561.528    1370.6594    1370.6594 
Loop time of 31.4256 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.749 ns/day, 8.729 hours/ns, 31.821 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    | 30.867     | 30.867     | 30.867     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12584    | 0.12584    | 0.12584    |   0.0 |  0.40
Output  | 0.00015478 | 0.00015478 | 0.00015478 |   0.0 |  0.00
Modify  | 0.36812    | 0.36812    | 0.36812    |   0.0 |  1.17
Other   |            | 0.06411    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5401.00 ave        5401 max        5401 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333184.0 ave      333184 max      333184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333184
Ave neighs/atom = 166.59200
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 = 272.872944362009, Press = -0.012653591157697
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  100000   -8032.9189   -8032.9189   -8106.1284   -8106.1284    283.32856    283.32856    21561.528    21561.528    1370.6594    1370.6594 
  101000   -8039.4401   -8039.4401   -8109.4897   -8109.4897    271.09886    271.09886    21542.577    21542.577    2174.7077    2174.7077 
Loop time of 32.4087 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.666 ns/day, 9.002 hours/ns, 30.856 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    | 31.838     | 31.838     | 31.838     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12753    | 0.12753    | 0.12753    |   0.0 |  0.39
Output  | 0.0001497  | 0.0001497  | 0.0001497  |   0.0 |  0.00
Modify  | 0.37865    | 0.37865    | 0.37865    |   0.0 |  1.17
Other   |            | 0.06417    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5399.00 ave        5399 max        5399 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333384.0 ave      333384 max      333384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333384
Ave neighs/atom = 166.69200
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 = 272.895818581643, Press = -0.699957612292188
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  101000   -8039.4401   -8039.4401   -8109.4897   -8109.4897    271.09886    271.09886    21542.577    21542.577    2174.7077    2174.7077 
  102000   -8038.8343   -8038.8343   -8110.2566   -8110.2566    276.41168    276.41168    21593.353    21593.353    -1292.109    -1292.109 
Loop time of 31.8419 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.713 ns/day, 8.845 hours/ns, 31.405 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    | 31.278     | 31.278     | 31.278     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12657    | 0.12657    | 0.12657    |   0.0 |  0.40
Output  | 0.00015508 | 0.00015508 | 0.00015508 |   0.0 |  0.00
Modify  | 0.37304    | 0.37304    | 0.37304    |   0.0 |  1.17
Other   |            | 0.06427    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5416.00 ave        5416 max        5416 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333632.0 ave      333632 max      333632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333632
Ave neighs/atom = 166.81600
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 = 272.909565107955, Press = -1.11763466416353
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  102000   -8038.8343   -8038.8343   -8110.2566   -8110.2566    276.41168    276.41168    21593.353    21593.353    -1292.109    -1292.109 
  103000   -8043.4639   -8043.4639   -8110.6913   -8110.6913    260.17715    260.17715    21549.857    21549.857    794.62267    794.62267 
Loop time of 32.0455 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.696 ns/day, 8.902 hours/ns, 31.206 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    | 31.481     | 31.481     | 31.481     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1271     | 0.1271     | 0.1271     |   0.0 |  0.40
Output  | 0.00015355 | 0.00015355 | 0.00015355 |   0.0 |  0.00
Modify  | 0.3737     | 0.3737     | 0.3737     |   0.0 |  1.17
Other   |            | 0.06398    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5393.00 ave        5393 max        5393 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332840.0 ave      332840 max      332840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332840
Ave neighs/atom = 166.42000
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 = 272.916909711227, Press = -0.0368510056564231
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  103000   -8043.4639   -8043.4639   -8110.6913   -8110.6913    260.17715    260.17715    21549.857    21549.857    794.62267    794.62267 
  104000   -8038.1651   -8038.1651   -8108.9962   -8108.9962    274.12369    274.12369    21543.959    21543.959    1622.4341    1622.4341 
Loop time of 30.8813 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.798 ns/day, 8.578 hours/ns, 32.382 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    | 30.333     | 30.333     | 30.333     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12327    | 0.12327    | 0.12327    |   0.0 |  0.40
Output  | 0.00015252 | 0.00015252 | 0.00015252 |   0.0 |  0.00
Modify  | 0.36146    | 0.36146    | 0.36146    |   0.0 |  1.17
Other   |            | 0.06351    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5410.00 ave        5410 max        5410 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333910.0 ave      333910 max      333910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333910
Ave neighs/atom = 166.95500
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 = 272.891624384021, Press = -0.680451110590472
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  104000   -8038.1651   -8038.1651   -8108.9962   -8108.9962    274.12369    274.12369    21543.959    21543.959    1622.4341    1622.4341 
  105000   -8040.7415   -8040.7415   -8110.4895   -8110.4895    269.93208    269.93208    21525.839    21525.839    2505.2459    2505.2459 
Loop time of 31.88 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.710 ns/day, 8.856 hours/ns, 31.368 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    | 31.314     | 31.314     | 31.314     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12663    | 0.12663    | 0.12663    |   0.0 |  0.40
Output  | 0.00015633 | 0.00015633 | 0.00015633 |   0.0 |  0.00
Modify  | 0.37514    | 0.37514    | 0.37514    |   0.0 |  1.18
Other   |            | 0.06423    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5408.00 ave        5408 max        5408 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333612.0 ave      333612 max      333612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333612
Ave neighs/atom = 166.80600
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 = 272.883932649819, Press = -0.905613024405133
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  105000   -8040.7415   -8040.7415   -8110.4895   -8110.4895    269.93208    269.93208    21525.839    21525.839    2505.2459    2505.2459 
  106000   -8040.7069   -8040.7069   -8109.3451   -8109.3451    265.63693    265.63693    21583.197    21583.197   -2029.9336   -2029.9336 
Loop time of 31.5125 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.742 ns/day, 8.753 hours/ns, 31.733 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    | 30.95      | 30.95      | 30.95      |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12747    | 0.12747    | 0.12747    |   0.0 |  0.40
Output  | 0.00015721 | 0.00015721 | 0.00015721 |   0.0 |  0.00
Modify  | 0.37011    | 0.37011    | 0.37011    |   0.0 |  1.17
Other   |            | 0.06447    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5431.00 ave        5431 max        5431 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      334116.0 ave      334116 max      334116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334116
Ave neighs/atom = 167.05800
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 = 272.869647726583, Press = -0.536227204262951
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  106000   -8040.7069   -8040.7069   -8109.3451   -8109.3451    265.63693    265.63693    21583.197    21583.197   -2029.9336   -2029.9336 
  107000   -8040.2042   -8040.2042   -8108.2076   -8108.2076    263.18025    263.18025        21543        21543     2234.332     2234.332 
Loop time of 31.7973 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.717 ns/day, 8.833 hours/ns, 31.449 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.234     | 31.234     | 31.234     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12588    | 0.12588    | 0.12588    |   0.0 |  0.40
Output  | 0.00015509 | 0.00015509 | 0.00015509 |   0.0 |  0.00
Modify  | 0.37316    | 0.37316    | 0.37316    |   0.0 |  1.17
Other   |            | 0.06426    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5405.00 ave        5405 max        5405 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333186.0 ave      333186 max      333186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333186
Ave neighs/atom = 166.59300
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 = 272.882936603647, Press = 0.00413476728575647
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  107000   -8040.2042   -8040.2042   -8108.2076   -8108.2076    263.18025    263.18025        21543        21543     2234.332     2234.332 
  108000   -8037.0012   -8037.0012    -8107.586    -8107.586     273.1706     273.1706    21560.076    21560.076    983.15713    983.15713 
Loop time of 31.3823 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.753 ns/day, 8.717 hours/ns, 31.865 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    | 30.826     | 30.826     | 30.826     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12469    | 0.12469    | 0.12469    |   0.0 |  0.40
Output  | 0.00015411 | 0.00015411 | 0.00015411 |   0.0 |  0.00
Modify  | 0.36738    | 0.36738    | 0.36738    |   0.0 |  1.17
Other   |            | 0.0641     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5406.00 ave        5406 max        5406 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333698.0 ave      333698 max      333698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333698
Ave neighs/atom = 166.84900
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 = 272.889999699811, Press = -0.720109244670141
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  108000   -8037.0012   -8037.0012    -8107.586    -8107.586     273.1706     273.1706    21560.076    21560.076    983.15713    983.15713 
  109000   -8040.7536   -8040.7536   -8110.3489   -8110.3489    269.34074    269.34074    21602.227    21602.227   -2353.7849   -2353.7849 
Loop time of 32.1776 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.685 ns/day, 8.938 hours/ns, 31.077 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    | 31.607     | 31.607     | 31.607     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12763    | 0.12763    | 0.12763    |   0.0 |  0.40
Output  | 0.0001546  | 0.0001546  | 0.0001546  |   0.0 |  0.00
Modify  | 0.37876    | 0.37876    | 0.37876    |   0.0 |  1.18
Other   |            | 0.06422    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5406.00 ave        5406 max        5406 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333502.0 ave      333502 max      333502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333502
Ave neighs/atom = 166.75100
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 = 272.867434164265, Press = -0.92240805922054
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  109000   -8040.7536   -8040.7536   -8110.3489   -8110.3489    269.34074    269.34074    21602.227    21602.227   -2353.7849   -2353.7849 
  110000   -8036.9128   -8036.9128   -8107.2584   -8107.2584    272.24463    272.24463     21602.43     21602.43   -1763.5952   -1763.5952 
Loop time of 32.2049 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.683 ns/day, 8.946 hours/ns, 31.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    | 31.634     | 31.634     | 31.634     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12816    | 0.12816    | 0.12816    |   0.0 |  0.40
Output  | 0.00015571 | 0.00015571 | 0.00015571 |   0.0 |  0.00
Modify  | 0.37745    | 0.37745    | 0.37745    |   0.0 |  1.17
Other   |            | 0.06463    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5409.00 ave        5409 max        5409 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332788.0 ave      332788 max      332788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332788
Ave neighs/atom = 166.39400
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 = 272.857344695656, Press = 0.271305331829473
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  110000   -8036.9128   -8036.9128   -8107.2584   -8107.2584    272.24463    272.24463     21602.43     21602.43   -1763.5952   -1763.5952 
  111000   -8040.0601   -8040.0601   -8109.7183   -8109.7183    269.58469    269.58469    21543.126    21543.126    2195.3712    2195.3712 
Loop time of 31.8799 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.710 ns/day, 8.856 hours/ns, 31.368 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    | 31.311     | 31.311     | 31.311     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12777    | 0.12777    | 0.12777    |   0.0 |  0.40
Output  | 0.00015516 | 0.00015516 | 0.00015516 |   0.0 |  0.00
Modify  | 0.37598    | 0.37598    | 0.37598    |   0.0 |  1.18
Other   |            | 0.06494    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5397.00 ave        5397 max        5397 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332582.0 ave      332582 max      332582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332582
Ave neighs/atom = 166.29100
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 = 272.853186609699, Press = -0.512624381276208
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  111000   -8040.0601   -8040.0601   -8109.7183   -8109.7183    269.58469    269.58469    21543.126    21543.126    2195.3712    2195.3712 
  112000   -8037.5454   -8037.5454   -8109.2932   -8109.2932    277.67145    277.67145    21536.576    21536.576    1996.4384    1996.4384 
Loop time of 31.5316 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.740 ns/day, 8.759 hours/ns, 31.714 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    | 30.974     | 30.974     | 30.974     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1253     | 0.1253     | 0.1253     |   0.0 |  0.40
Output  | 0.00015379 | 0.00015379 | 0.00015379 |   0.0 |  0.00
Modify  | 0.36835    | 0.36835    | 0.36835    |   0.0 |  1.17
Other   |            | 0.06361    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5412.00 ave        5412 max        5412 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333762.0 ave      333762 max      333762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333762
Ave neighs/atom = 166.88100
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 = 272.857390154696, Press = -0.485819470918995
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  112000   -8037.5454   -8037.5454   -8109.2932   -8109.2932    277.67145    277.67145    21536.576    21536.576    1996.4384    1996.4384 
  113000   -8039.3297   -8039.3297    -8109.397    -8109.397    271.16768    271.16768    21563.092    21563.092   -87.831007   -87.831007 
Loop time of 31.9697 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.703 ns/day, 8.880 hours/ns, 31.280 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    | 31.405     | 31.405     | 31.405     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12647    | 0.12647    | 0.12647    |   0.0 |  0.40
Output  | 0.00015405 | 0.00015405 | 0.00015405 |   0.0 |  0.00
Modify  | 0.37321    | 0.37321    | 0.37321    |   0.0 |  1.17
Other   |            | 0.06437    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5411.00 ave        5411 max        5411 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333810.0 ave      333810 max      333810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333810
Ave neighs/atom = 166.90500
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 = 272.839242943074, Press = -0.264580752184177
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  113000   -8039.3297   -8039.3297    -8109.397    -8109.397    271.16768    271.16768    21563.092    21563.092   -87.831007   -87.831007 
  114000   -8037.1678   -8037.1678   -8107.9274   -8107.9274    273.84701    273.84701    21591.894    21591.894    882.15136    882.15136 
Loop time of 32.7299 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.640 ns/day, 9.092 hours/ns, 30.553 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    | 32.145     | 32.145     | 32.145     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13159    | 0.13159    | 0.13159    |   0.0 |  0.40
Output  | 0.00015247 | 0.00015247 | 0.00015247 |   0.0 |  0.00
Modify  | 0.38779    | 0.38779    | 0.38779    |   0.0 |  1.18
Other   |            | 0.06506    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5412.00 ave        5412 max        5412 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333202.0 ave      333202 max      333202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333202
Ave neighs/atom = 166.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 = 272.832386944862, Press = -0.437971695940229
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  114000   -8037.1678   -8037.1678   -8107.9274   -8107.9274    273.84701    273.84701    21591.894    21591.894    882.15136    882.15136 
  115000   -8035.9189   -8035.9189   -8108.0941   -8108.0941     279.3256     279.3256    21586.335    21586.335   -1173.5918   -1173.5918 
Loop time of 32.4191 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.665 ns/day, 9.005 hours/ns, 30.846 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    | 31.846     | 31.846     | 31.846     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12857    | 0.12857    | 0.12857    |   0.0 |  0.40
Output  | 0.00015277 | 0.00015277 | 0.00015277 |   0.0 |  0.00
Modify  | 0.37944    | 0.37944    | 0.37944    |   0.0 |  1.17
Other   |            | 0.06519    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5405.00 ave        5405 max        5405 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333048.0 ave      333048 max      333048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333048
Ave neighs/atom = 166.52400
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 = 272.840314086444, Press = -0.305941475997378
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  115000   -8035.9189   -8035.9189   -8108.0941   -8108.0941     279.3256     279.3256    21586.335    21586.335   -1173.5918   -1173.5918 
  116000   -8037.1212   -8037.1212   -8110.0184   -8110.0184    282.11991    282.11991    21554.811    21554.811    463.28855    463.28855 
Loop time of 32.8718 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.628 ns/day, 9.131 hours/ns, 30.421 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.295     | 32.295     | 32.295     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13061    | 0.13061    | 0.13061    |   0.0 |  0.40
Output  | 0.00015896 | 0.00015896 | 0.00015896 |   0.0 |  0.00
Modify  | 0.38155    | 0.38155    | 0.38155    |   0.0 |  1.16
Other   |            | 0.0641     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5412.00 ave        5412 max        5412 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333042.0 ave      333042 max      333042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333042
Ave neighs/atom = 166.52100
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 = 272.843220483696, Press = -0.279783454778623
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  116000   -8037.1212   -8037.1212   -8110.0184   -8110.0184    282.11991    282.11991    21554.811    21554.811    463.28855    463.28855 
  117000   -8039.9208   -8039.9208   -8108.4313   -8108.4313    265.14266    265.14266    21532.491    21532.491    2969.5028    2969.5028 
Loop time of 31.8242 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.715 ns/day, 8.840 hours/ns, 31.423 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    | 31.26      | 31.26      | 31.26      |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12734    | 0.12734    | 0.12734    |   0.0 |  0.40
Output  | 0.00019561 | 0.00019561 | 0.00019561 |   0.0 |  0.00
Modify  | 0.37216    | 0.37216    | 0.37216    |   0.0 |  1.17
Other   |            | 0.06474    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5423.00 ave        5423 max        5423 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333672.0 ave      333672 max      333672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333672
Ave neighs/atom = 166.83600
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 = 272.854874874661, Press = -1.51443302453189
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  117000   -8039.9208   -8039.9208   -8108.4313   -8108.4313    265.14266    265.14266    21532.491    21532.491    2969.5028    2969.5028 
  118000   -8034.1137   -8034.1137   -8106.4061   -8106.4061    279.77912    279.77912    21610.827    21610.827     -1717.53     -1717.53 
Loop time of 31.9531 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.704 ns/day, 8.876 hours/ns, 31.296 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    | 31.386     | 31.386     | 31.386     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12754    | 0.12754    | 0.12754    |   0.0 |  0.40
Output  | 0.00015532 | 0.00015532 | 0.00015532 |   0.0 |  0.00
Modify  | 0.37397    | 0.37397    | 0.37397    |   0.0 |  1.17
Other   |            | 0.06494    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5419.00 ave        5419 max        5419 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      334052.0 ave      334052 max      334052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334052
Ave neighs/atom = 167.02600
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 = 272.874172813209, Press = -1.09786699490669
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  118000   -8034.1137   -8034.1137   -8106.4061   -8106.4061    279.77912    279.77912    21610.827    21610.827     -1717.53     -1717.53 
  119000   -8035.8327   -8035.8327   -8107.7183   -8107.7183    278.20485    278.20485      21562.3      21562.3    2018.3376    2018.3376 
Loop time of 33.1737 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.604 ns/day, 9.215 hours/ns, 30.144 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    | 32.588     | 32.588     | 32.588     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13132    | 0.13132    | 0.13132    |   0.0 |  0.40
Output  | 0.00019304 | 0.00019304 | 0.00019304 |   0.0 |  0.00
Modify  | 0.38853    | 0.38853    | 0.38853    |   0.0 |  1.17
Other   |            | 0.0655     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5392.00 ave        5392 max        5392 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332430.0 ave      332430 max      332430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332430
Ave neighs/atom = 166.21500
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 = 272.884817174481, Press = 0.171212174728373
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  119000   -8035.8327   -8035.8327   -8107.7183   -8107.7183    278.20485    278.20485      21562.3      21562.3    2018.3376    2018.3376 
  120000   -8042.0232   -8042.0232   -8111.5906   -8111.5906    269.23302    269.23302    21566.241    21566.241   -761.59034   -761.59034 
Loop time of 31.4811 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.745 ns/day, 8.745 hours/ns, 31.765 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    | 30.926     | 30.926     | 30.926     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12534    | 0.12534    | 0.12534    |   0.0 |  0.40
Output  | 0.00015355 | 0.00015355 | 0.00015355 |   0.0 |  0.00
Modify  | 0.36549    | 0.36549    | 0.36549    |   0.0 |  1.16
Other   |            | 0.06421    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5393.00 ave        5393 max        5393 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333378.0 ave      333378 max      333378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333378
Ave neighs/atom = 166.68900
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 = 272.884213218071, Press = -0.350410583195982
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  120000   -8042.0232   -8042.0232   -8111.5906   -8111.5906    269.23302    269.23302    21566.241    21566.241   -761.59034   -761.59034 
  121000    -8037.002    -8037.002   -8108.2305   -8108.2305    275.66142    275.66142    21560.816    21560.816    365.02845    365.02845 
Loop time of 31.5879 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.735 ns/day, 8.774 hours/ns, 31.658 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    | 31.029     | 31.029     | 31.029     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12537    | 0.12537    | 0.12537    |   0.0 |  0.40
Output  | 0.00015567 | 0.00015567 | 0.00015567 |   0.0 |  0.00
Modify  | 0.36884    | 0.36884    | 0.36884    |   0.0 |  1.17
Other   |            | 0.06455    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5414.00 ave        5414 max        5414 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333266.0 ave      333266 max      333266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333266
Ave neighs/atom = 166.63300
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 = 272.86722547538, Press = -1.02252222172023
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  121000    -8037.002    -8037.002   -8108.2305   -8108.2305    275.66142    275.66142    21560.816    21560.816    365.02845    365.02845 
  122000   -8037.7335   -8037.7335    -8109.806    -8109.806    278.92815    278.92815    21584.281    21584.281   -1338.4055   -1338.4055 
Loop time of 32.124 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.690 ns/day, 8.923 hours/ns, 31.129 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    | 31.554     | 31.554     | 31.554     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12876    | 0.12876    | 0.12876    |   0.0 |  0.40
Output  | 0.00015441 | 0.00015441 | 0.00015441 |   0.0 |  0.00
Modify  | 0.37728    | 0.37728    | 0.37728    |   0.0 |  1.17
Other   |            | 0.06417    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5408.00 ave        5408 max        5408 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333726.0 ave      333726 max      333726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333726
Ave neighs/atom = 166.86300
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 = 272.849256792968, Press = -0.969605810499115
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  122000   -8037.7335   -8037.7335    -8109.806    -8109.806    278.92815    278.92815    21584.281    21584.281   -1338.4055   -1338.4055 
  123000   -8041.2227   -8041.2227    -8110.161    -8110.161    266.79823    266.79823    21581.767    21581.767   -1448.5317   -1448.5317 
Loop time of 32.455 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.662 ns/day, 9.015 hours/ns, 30.812 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    | 31.885     | 31.885     | 31.885     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12878    | 0.12878    | 0.12878    |   0.0 |  0.40
Output  | 0.00015684 | 0.00015684 | 0.00015684 |   0.0 |  0.00
Modify  | 0.37639    | 0.37639    | 0.37639    |   0.0 |  1.16
Other   |            | 0.06474    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5405.00 ave        5405 max        5405 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332824.0 ave      332824 max      332824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332824
Ave neighs/atom = 166.41200
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 = 272.840145674081, Press = -0.771104966897754
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  123000   -8041.2227   -8041.2227    -8110.161    -8110.161    266.79823    266.79823    21581.767    21581.767   -1448.5317   -1448.5317 
  124000   -8039.0238   -8039.0238   -8109.3069   -8109.3069    272.00302    272.00302    21565.476    21565.476    470.02485    470.02485 
Loop time of 31.4532 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.747 ns/day, 8.737 hours/ns, 31.793 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    | 30.895     | 30.895     | 30.895     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12678    | 0.12678    | 0.12678    |   0.0 |  0.40
Output  | 0.0001547  | 0.0001547  | 0.0001547  |   0.0 |  0.00
Modify  | 0.36755    | 0.36755    | 0.36755    |   0.0 |  1.17
Other   |            | 0.06411    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5416.00 ave        5416 max        5416 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333266.0 ave      333266 max      333266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333266
Ave neighs/atom = 166.63300
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 = 272.840643966624, Press = 0.0686132383059043
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  124000   -8039.0238   -8039.0238   -8109.3069   -8109.3069    272.00302    272.00302    21565.476    21565.476    470.02485    470.02485 
  125000    -8039.688    -8039.688   -8111.8004   -8111.8004    279.08234    279.08234    21572.642    21572.642   -891.86834   -891.86834 
Loop time of 33.2889 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.595 ns/day, 9.247 hours/ns, 30.040 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    | 32.707     | 32.707     | 32.707     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1304     | 0.1304     | 0.1304     |   0.0 |  0.39
Output  | 0.00020203 | 0.00020203 | 0.00020203 |   0.0 |  0.00
Modify  | 0.3862     | 0.3862     | 0.3862     |   0.0 |  1.16
Other   |            | 0.06497    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5406.00 ave        5406 max        5406 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333408.0 ave      333408 max      333408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333408
Ave neighs/atom = 166.70400
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 = 272.824759058953, Press = -0.281497403974858
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  125000    -8039.688    -8039.688   -8111.8004   -8111.8004    279.08234    279.08234    21572.642    21572.642   -891.86834   -891.86834 
  126000   -8037.3659   -8037.3659   -8107.3961   -8107.3961    271.02409    271.02409    21582.047    21582.047    240.63006    240.63006 
Loop time of 32.1182 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.690 ns/day, 8.922 hours/ns, 31.135 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    | 31.553     | 31.553     | 31.553     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12705    | 0.12705    | 0.12705    |   0.0 |  0.40
Output  | 0.0001533  | 0.0001533  | 0.0001533  |   0.0 |  0.00
Modify  | 0.3734     | 0.3734     | 0.3734     |   0.0 |  1.16
Other   |            | 0.06455    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5414.00 ave        5414 max        5414 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333310.0 ave      333310 max      333310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333310
Ave neighs/atom = 166.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 = 272.820870775324, Press = -0.519105689271926
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  126000   -8037.3659   -8037.3659   -8107.3961   -8107.3961    271.02409    271.02409    21582.047    21582.047    240.63006    240.63006 
  127000    -8040.679    -8040.679   -8110.5257   -8110.5257    270.31423    270.31423     21590.18     21590.18   -2657.2894   -2657.2894 
Loop time of 32.5558 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.654 ns/day, 9.043 hours/ns, 30.716 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.989     | 31.989     | 31.989     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12755    | 0.12755    | 0.12755    |   0.0 |  0.39
Output  | 0.00015484 | 0.00015484 | 0.00015484 |   0.0 |  0.00
Modify  | 0.37544    | 0.37544    | 0.37544    |   0.0 |  1.15
Other   |            | 0.06401    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5419.00 ave        5419 max        5419 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333194.0 ave      333194 max      333194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333194
Ave neighs/atom = 166.59700
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 = 272.803825579898, Press = -0.363610269904614
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  127000    -8040.679    -8040.679   -8110.5257   -8110.5257    270.31423    270.31423     21590.18     21590.18   -2657.2894   -2657.2894 
  128000   -8040.0565   -8040.0565   -8110.2397   -8110.2397    271.61628    271.61628    21551.842    21551.842    1085.8423    1085.8423 
Loop time of 32.3914 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.667 ns/day, 8.998 hours/ns, 30.872 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    | 31.823     | 31.823     | 31.823     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12716    | 0.12716    | 0.12716    |   0.0 |  0.39
Output  | 0.00015338 | 0.00015338 | 0.00015338 |   0.0 |  0.00
Modify  | 0.3765     | 0.3765     | 0.3765     |   0.0 |  1.16
Other   |            | 0.06476    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5401.00 ave        5401 max        5401 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332846.0 ave      332846 max      332846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332846
Ave neighs/atom = 166.42300
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 = 272.799959332297, Press = 0.400880637101306
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  128000   -8040.0565   -8040.0565   -8110.2397   -8110.2397    271.61628    271.61628    21551.842    21551.842    1085.8423    1085.8423 
  129000   -8036.3486   -8036.3486   -8107.0876   -8107.0876    273.76739    273.76739      21590.9      21590.9   -80.433471   -80.433471 
Loop time of 33.7482 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.560 ns/day, 9.374 hours/ns, 29.631 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    | 33.155     | 33.155     | 33.155     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13229    | 0.13229    | 0.13229    |   0.0 |  0.39
Output  | 0.00015544 | 0.00015544 | 0.00015544 |   0.0 |  0.00
Modify  | 0.3959     | 0.3959     | 0.3959     |   0.0 |  1.17
Other   |            | 0.06514    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5403.00 ave        5403 max        5403 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333590.0 ave      333590 max      333590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333590
Ave neighs/atom = 166.79500
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 = 272.81140506099, Press = -0.0900498610667366
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  129000   -8036.3486   -8036.3486   -8107.0876   -8107.0876    273.76739    273.76739      21590.9      21590.9   -80.433471   -80.433471 
  130000   -8035.3031   -8035.3031   -8107.8472   -8107.8472    280.75285    280.75285    21563.692    21563.692     1162.387     1162.387 
Loop time of 32.8054 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.634 ns/day, 9.113 hours/ns, 30.483 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    | 32.227     | 32.227     | 32.227     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12911    | 0.12911    | 0.12911    |   0.0 |  0.39
Output  | 0.00015706 | 0.00015706 | 0.00015706 |   0.0 |  0.00
Modify  | 0.38443    | 0.38443    | 0.38443    |   0.0 |  1.17
Other   |            | 0.06494    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5406.00 ave        5406 max        5406 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332924.0 ave      332924 max      332924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332924
Ave neighs/atom = 166.46200
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 = 272.815606078293, Press = -0.255164864154171
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  130000   -8035.3031   -8035.3031   -8107.8472   -8107.8472    280.75285    280.75285    21563.692    21563.692     1162.387     1162.387 
  131000   -8038.7225   -8038.7225   -8109.7106   -8109.7106    274.73109    274.73109    21553.015    21553.015     3.460211     3.460211 
Loop time of 31.9468 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.704 ns/day, 8.874 hours/ns, 31.302 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    | 31.386     | 31.386     | 31.386     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12609    | 0.12609    | 0.12609    |   0.0 |  0.39
Output  | 0.00015488 | 0.00015488 | 0.00015488 |   0.0 |  0.00
Modify  | 0.36922    | 0.36922    | 0.36922    |   0.0 |  1.16
Other   |            | 0.06491    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5417.00 ave        5417 max        5417 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333108.0 ave      333108 max      333108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333108
Ave neighs/atom = 166.55400
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 = 272.837838855373, Press = -0.37142072239249
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  131000   -8038.7225   -8038.7225   -8109.7106   -8109.7106    274.73109    274.73109    21553.015    21553.015     3.460211     3.460211 
  132000     -8038.32     -8038.32     -8109.25     -8109.25    274.50637    274.50637    21589.324    21589.324   -1479.1233   -1479.1233 
Loop time of 32.1184 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.690 ns/day, 8.922 hours/ns, 31.135 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    | 31.555     | 31.555     | 31.555     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12688    | 0.12688    | 0.12688    |   0.0 |  0.40
Output  | 0.00015375 | 0.00015375 | 0.00015375 |   0.0 |  0.00
Modify  | 0.37285    | 0.37285    | 0.37285    |   0.0 |  1.16
Other   |            | 0.06392    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5414.00 ave        5414 max        5414 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333544.0 ave      333544 max      333544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333544
Ave neighs/atom = 166.77200
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 = 272.836972783708, Press = -1.17119910715106
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  132000     -8038.32     -8038.32     -8109.25     -8109.25    274.50637    274.50637    21589.324    21589.324   -1479.1233   -1479.1233 
  133000   -8038.7123   -8038.7123   -8110.2192   -8110.2192    276.73921    276.73921    21568.665    21568.665    52.294315    52.294315 
Loop time of 32.2098 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.682 ns/day, 8.947 hours/ns, 31.046 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    | 31.643     | 31.643     | 31.643     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12645    | 0.12645    | 0.12645    |   0.0 |  0.39
Output  | 0.00019995 | 0.00019995 | 0.00019995 |   0.0 |  0.00
Modify  | 0.37603    | 0.37603    | 0.37603    |   0.0 |  1.17
Other   |            | 0.06439    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5402.00 ave        5402 max        5402 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332932.0 ave      332932 max      332932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332932
Ave neighs/atom = 166.46600
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 = 272.836782684302, Press = 0.320561566738742
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  133000   -8038.7123   -8038.7123   -8110.2192   -8110.2192    276.73921    276.73921    21568.665    21568.665    52.294315    52.294315 
  134000   -8036.1395   -8036.1395   -8107.5551   -8107.5551    276.38583    276.38583     21549.69     21549.69    2078.8541    2078.8541 
Loop time of 31.7638 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.720 ns/day, 8.823 hours/ns, 31.482 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    | 31.203     | 31.203     | 31.203     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1257     | 0.1257     | 0.1257     |   0.0 |  0.40
Output  | 0.00019583 | 0.00019583 | 0.00019583 |   0.0 |  0.00
Modify  | 0.37034    | 0.37034    | 0.37034    |   0.0 |  1.17
Other   |            | 0.06477    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5421.00 ave        5421 max        5421 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333200.0 ave      333200 max      333200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333200
Ave neighs/atom = 166.60000
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 = 272.844608983476, Press = -0.395682388463736
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  134000   -8036.1395   -8036.1395   -8107.5551   -8107.5551    276.38583    276.38583     21549.69     21549.69    2078.8541    2078.8541 
  135000   -8038.5652   -8038.5652    -8110.343    -8110.343    277.78741    277.78741    21517.646    21517.646    2755.8902    2755.8902 
Loop time of 31.958 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.704 ns/day, 8.877 hours/ns, 31.291 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.391     | 31.391     | 31.391     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12738    | 0.12738    | 0.12738    |   0.0 |  0.40
Output  | 0.00015302 | 0.00015302 | 0.00015302 |   0.0 |  0.00
Modify  | 0.37426    | 0.37426    | 0.37426    |   0.0 |  1.17
Other   |            | 0.06482    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5411.00 ave        5411 max        5411 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333754.0 ave      333754 max      333754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333754
Ave neighs/atom = 166.87700
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 = 272.850152384074, Press = -0.756915332074951
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  135000   -8038.5652   -8038.5652    -8110.343    -8110.343    277.78741    277.78741    21517.646    21517.646    2755.8902    2755.8902 
  136000   -8036.9897   -8036.9897   -8109.7864   -8109.7864    281.73084    281.73084    21567.161    21567.161    53.921215    53.921215 
Loop time of 32.276 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.677 ns/day, 8.966 hours/ns, 30.983 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    | 31.708     | 31.708     | 31.708     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12778    | 0.12778    | 0.12778    |   0.0 |  0.40
Output  | 0.00015697 | 0.00015697 | 0.00015697 |   0.0 |  0.00
Modify  | 0.37584    | 0.37584    | 0.37584    |   0.0 |  1.16
Other   |            | 0.06444    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5394.00 ave        5394 max        5394 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      334034.0 ave      334034 max      334034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334034
Ave neighs/atom = 167.01700
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 = 272.876294034198, Press = -0.865497917206289
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  136000   -8036.9897   -8036.9897   -8109.7864   -8109.7864    281.73084    281.73084    21567.161    21567.161    53.921215    53.921215 
  137000   -8038.5956   -8038.5956   -8109.3439   -8109.3439    273.80315    273.80315    21631.484    21631.484   -3866.6249   -3866.6249 
Loop time of 32.3952 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.667 ns/day, 8.999 hours/ns, 30.869 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    | 31.824     | 31.824     | 31.824     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12793    | 0.12793    | 0.12793    |   0.0 |  0.39
Output  | 0.00020001 | 0.00020001 | 0.00020001 |   0.0 |  0.00
Modify  | 0.37846    | 0.37846    | 0.37846    |   0.0 |  1.17
Other   |            | 0.06443    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5417.00 ave        5417 max        5417 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333386.0 ave      333386 max      333386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333386
Ave neighs/atom = 166.69300
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 = 272.882278080577, Press = -0.379412909748325
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  137000   -8038.5956   -8038.5956   -8109.3439   -8109.3439    273.80315    273.80315    21631.484    21631.484   -3866.6249   -3866.6249 
  138000   -8037.6656   -8037.6656   -8109.1736   -8109.1736    276.74364    276.74364    21577.342    21577.342   -734.44031   -734.44031 
Loop time of 31.5446 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.739 ns/day, 8.762 hours/ns, 31.701 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    | 30.985     | 30.985     | 30.985     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12547    | 0.12547    | 0.12547    |   0.0 |  0.40
Output  | 0.00015656 | 0.00015656 | 0.00015656 |   0.0 |  0.00
Modify  | 0.36969    | 0.36969    | 0.36969    |   0.0 |  1.17
Other   |            | 0.06439    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5401.00 ave        5401 max        5401 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332266.0 ave      332266 max      332266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332266
Ave neighs/atom = 166.13300
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 = 272.896204846506, Press = -0.053865897565892
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  138000   -8037.6656   -8037.6656   -8109.1736   -8109.1736    276.74364    276.74364    21577.342    21577.342   -734.44031   -734.44031 
  139000    -8039.742    -8039.742   -8108.4239   -8108.4239    265.80589    265.80589    21573.577    21573.577    1080.3154    1080.3154 
Loop time of 32.5283 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.656 ns/day, 9.036 hours/ns, 30.742 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    | 31.952     | 31.952     | 31.952     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12953    | 0.12953    | 0.12953    |   0.0 |  0.40
Output  | 0.00015578 | 0.00015578 | 0.00015578 |   0.0 |  0.00
Modify  | 0.38208    | 0.38208    | 0.38208    |   0.0 |  1.17
Other   |            | 0.06485    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5414.00 ave        5414 max        5414 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332940.0 ave      332940 max      332940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332940
Ave neighs/atom = 166.47000
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 = 272.890260715338, Press = -0.528480344190165
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  139000    -8039.742    -8039.742   -8108.4239   -8108.4239    265.80589    265.80589    21573.577    21573.577    1080.3154    1080.3154 
  140000   -8038.5907   -8038.5907   -8109.2633   -8109.2633    273.51036    273.51036     21555.92     21555.92   -215.13254   -215.13254 
Loop time of 32.5084 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.658 ns/day, 9.030 hours/ns, 30.761 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.934     | 31.934     | 31.934     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12947    | 0.12947    | 0.12947    |   0.0 |  0.40
Output  | 0.00015708 | 0.00015708 | 0.00015708 |   0.0 |  0.00
Modify  | 0.38045    | 0.38045    | 0.38045    |   0.0 |  1.17
Other   |            | 0.06474    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5412.00 ave        5412 max        5412 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333488.0 ave      333488 max      333488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333488
Ave neighs/atom = 166.74400
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 = 272.894778202604, Press = -0.00841461723545213
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  140000   -8038.5907   -8038.5907   -8109.2633   -8109.2633    273.51036    273.51036     21555.92     21555.92   -215.13254   -215.13254 
  141000    -8038.719    -8038.719   -8108.1674   -8108.1674    268.77239    268.77239    21577.211    21577.211   -219.40633   -219.40633 
Loop time of 32.203 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.683 ns/day, 8.945 hours/ns, 31.053 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    | 31.632     | 31.632     | 31.632     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12888    | 0.12888    | 0.12888    |   0.0 |  0.40
Output  | 0.00015342 | 0.00015342 | 0.00015342 |   0.0 |  0.00
Modify  | 0.3772     | 0.3772     | 0.3772     |   0.0 |  1.17
Other   |            | 0.06481    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5413.00 ave        5413 max        5413 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333578.0 ave      333578 max      333578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333578
Ave neighs/atom = 166.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 = 272.889135041624, Press = -0.331782719189243
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  141000    -8038.719    -8038.719   -8108.1674   -8108.1674    268.77239    268.77239    21577.211    21577.211   -219.40633   -219.40633 
  142000   -8038.1626   -8038.1626   -8108.6284   -8108.6284    272.70992    272.70992    21530.072    21530.072    3233.0728    3233.0728 
Loop time of 32.0294 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.698 ns/day, 8.897 hours/ns, 31.221 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    | 31.467     | 31.467     | 31.467     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12733    | 0.12733    | 0.12733    |   0.0 |  0.40
Output  | 0.00015065 | 0.00015065 | 0.00015065 |   0.0 |  0.00
Modify  | 0.37111    | 0.37111    | 0.37111    |   0.0 |  1.16
Other   |            | 0.06425    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5413.00 ave        5413 max        5413 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333272.0 ave      333272 max      333272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333272
Ave neighs/atom = 166.63600
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 = 272.88476416548, Press = -0.38476675185777
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  142000   -8038.1626   -8038.1626   -8108.6284   -8108.6284    272.70992    272.70992    21530.072    21530.072    3233.0728    3233.0728 
  143000   -8039.4438   -8039.4438   -8107.9022   -8107.9022     264.9411     264.9411    21588.739    21588.739   -459.65329   -459.65329 
Loop time of 31.4531 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.747 ns/day, 8.737 hours/ns, 31.793 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    | 30.894     | 30.894     | 30.894     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12571    | 0.12571    | 0.12571    |   0.0 |  0.40
Output  | 0.00015874 | 0.00015874 | 0.00015874 |   0.0 |  0.00
Modify  | 0.36879    | 0.36879    | 0.36879    |   0.0 |  1.17
Other   |            | 0.06432    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5422.00 ave        5422 max        5422 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333952.0 ave      333952 max      333952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333952
Ave neighs/atom = 166.97600
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 = 272.879912891112, Press = -0.924956934677151
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  143000   -8039.4438   -8039.4438   -8107.9022   -8107.9022     264.9411     264.9411    21588.739    21588.739   -459.65329   -459.65329 
  144000    -8040.542    -8040.542   -8110.6764   -8110.6764    271.42721    271.42721    21598.785    21598.785   -3424.7845   -3424.7845 
Loop time of 31.7362 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.722 ns/day, 8.816 hours/ns, 31.510 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.175     | 31.175     | 31.175     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12536    | 0.12536    | 0.12536    |   0.0 |  0.40
Output  | 0.00016113 | 0.00016113 | 0.00016113 |   0.0 |  0.00
Modify  | 0.37128    | 0.37128    | 0.37128    |   0.0 |  1.17
Other   |            | 0.06435    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5409.00 ave        5409 max        5409 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333150.0 ave      333150 max      333150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333150
Ave neighs/atom = 166.57500
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 = 272.889178261962, Press = -0.477612958142587
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  144000    -8040.542    -8040.542   -8110.6764   -8110.6764    271.42721    271.42721    21598.785    21598.785   -3424.7845   -3424.7845 
  145000   -8038.7733   -8038.7733   -8109.2306   -8109.2306    272.67697    272.67697    21562.523    21562.523     503.8065     503.8065 
Loop time of 31.1986 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.769 ns/day, 8.666 hours/ns, 32.053 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    | 30.648     | 30.648     | 30.648     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12464    | 0.12464    | 0.12464    |   0.0 |  0.40
Output  | 0.00019135 | 0.00019135 | 0.00019135 |   0.0 |  0.00
Modify  | 0.36227    | 0.36227    | 0.36227    |   0.0 |  1.16
Other   |            | 0.06365    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5401.00 ave        5401 max        5401 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332780.0 ave      332780 max      332780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332780
Ave neighs/atom = 166.39000
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 = 272.886720497766, Press = -0.36528459179518
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  145000   -8038.7733   -8038.7733   -8109.2306   -8109.2306    272.67697    272.67697    21562.523    21562.523     503.8065     503.8065 
  146000   -8038.5915   -8038.5915   -8110.0885   -8110.0885    276.70068    276.70068    21564.074    21564.074    -485.1123    -485.1123 
Loop time of 31.3217 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.758 ns/day, 8.700 hours/ns, 31.927 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    | 30.765     | 30.765     | 30.765     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12546    | 0.12546    | 0.12546    |   0.0 |  0.40
Output  | 0.0001557  | 0.0001557  | 0.0001557  |   0.0 |  0.00
Modify  | 0.36689    | 0.36689    | 0.36689    |   0.0 |  1.17
Other   |            | 0.06451    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5416.00 ave        5416 max        5416 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333322.0 ave      333322 max      333322 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333322
Ave neighs/atom = 166.66100
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 = 272.888411617432, Press = -0.184956291440224
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  146000   -8038.5915   -8038.5915   -8110.0885   -8110.0885    276.70068    276.70068    21564.074    21564.074    -485.1123    -485.1123 
  147000   -8037.0257   -8037.0257   -8108.4856   -8108.4856    276.55725    276.55725    21547.146    21547.146    2336.9977    2336.9977 
Loop time of 32.4004 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.667 ns/day, 9.000 hours/ns, 30.864 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    | 31.828     | 31.828     | 31.828     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12922    | 0.12922    | 0.12922    |   0.0 |  0.40
Output  | 0.00015742 | 0.00015742 | 0.00015742 |   0.0 |  0.00
Modify  | 0.37868    | 0.37868    | 0.37868    |   0.0 |  1.17
Other   |            | 0.06434    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5405.00 ave        5405 max        5405 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333556.0 ave      333556 max      333556 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333556
Ave neighs/atom = 166.77800
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 = 272.896517142139, Press = -0.18592033619325
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  147000   -8037.0257   -8037.0257   -8108.4856   -8108.4856    276.55725    276.55725    21547.146    21547.146    2336.9977    2336.9977 
  148000   -8040.6861   -8040.6861   -8111.1009   -8111.1009    272.51261    272.51261    21511.777    21511.777    2828.7353    2828.7353 
Loop time of 32.12 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.690 ns/day, 8.922 hours/ns, 31.133 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    | 31.552     | 31.552     | 31.552     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12808    | 0.12808    | 0.12808    |   0.0 |  0.40
Output  | 0.00015552 | 0.00015552 | 0.00015552 |   0.0 |  0.00
Modify  | 0.37486    | 0.37486    | 0.37486    |   0.0 |  1.17
Other   |            | 0.06463    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5417.00 ave        5417 max        5417 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333584.0 ave      333584 max      333584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333584
Ave neighs/atom = 166.79200
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 = 272.894598696657, Press = -0.684365872715166
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  148000   -8040.6861   -8040.6861   -8111.1009   -8111.1009    272.51261    272.51261    21511.777    21511.777    2828.7353    2828.7353 
  149000   -8036.5806   -8036.5806   -8108.6949   -8108.6949    279.08954    279.08954    21592.569    21592.569   -793.30756   -793.30756 
Loop time of 31.9187 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.707 ns/day, 8.866 hours/ns, 31.330 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    | 31.352     | 31.352     | 31.352     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12732    | 0.12732    | 0.12732    |   0.0 |  0.40
Output  | 0.00015347 | 0.00015347 | 0.00015347 |   0.0 |  0.00
Modify  | 0.37516    | 0.37516    | 0.37516    |   0.0 |  1.18
Other   |            | 0.06439    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5401.00 ave        5401 max        5401 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      334140.0 ave      334140 max      334140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334140
Ave neighs/atom = 167.07000
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 = 272.895774817912, Press = -0.437580916822549
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  149000   -8036.5806   -8036.5806   -8108.6949   -8108.6949    279.08954    279.08954    21592.569    21592.569   -793.30756   -793.30756 
  150000   -8039.3678   -8039.3678   -8110.0228   -8110.0228    273.44223    273.44223    21522.267    21522.267     2568.506     2568.506 
Loop time of 32.5492 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.654 ns/day, 9.041 hours/ns, 30.723 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    | 31.98      | 31.98      | 31.98      |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12972    | 0.12972    | 0.12972    |   0.0 |  0.40
Output  | 0.00015178 | 0.00015178 | 0.00015178 |   0.0 |  0.00
Modify  | 0.37558    | 0.37558    | 0.37558    |   0.0 |  1.15
Other   |            | 0.06343    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5415.00 ave        5415 max        5415 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332640.0 ave      332640 max      332640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332640
Ave neighs/atom = 166.32000
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 = 272.905216003182, Press = -0.0217652301161925
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  150000   -8039.3678   -8039.3678   -8110.0228   -8110.0228    273.44223    273.44223    21522.267    21522.267     2568.506     2568.506 
  151000    -8034.726    -8034.726   -8105.5241   -8105.5241    273.99562    273.99562    21568.062    21568.062    938.71179    938.71179 
Loop time of 31.8819 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.710 ns/day, 8.856 hours/ns, 31.366 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    | 31.32      | 31.32      | 31.32      |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12602    | 0.12602    | 0.12602    |   0.0 |  0.40
Output  | 0.00027561 | 0.00027561 | 0.00027561 |   0.0 |  0.00
Modify  | 0.37175    | 0.37175    | 0.37175    |   0.0 |  1.17
Other   |            | 0.06405    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5416.00 ave        5416 max        5416 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      334072.0 ave      334072 max      334072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 334072
Ave neighs/atom = 167.03600
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 = 272.921220620011, Press = -0.502788609655065
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  151000    -8034.726    -8034.726   -8105.5241   -8105.5241    273.99562    273.99562    21568.062    21568.062    938.71179    938.71179 
  152000   -8041.0112   -8041.0112   -8110.6237   -8110.6237    269.40756    269.40756    21569.686    21569.686   -1406.4268   -1406.4268 
Loop time of 31.6498 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.730 ns/day, 8.792 hours/ns, 31.596 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    | 31.092     | 31.092     | 31.092     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1249     | 0.1249     | 0.1249     |   0.0 |  0.39
Output  | 0.00020281 | 0.00020281 | 0.00020281 |   0.0 |  0.00
Modify  | 0.36906    | 0.36906    | 0.36906    |   0.0 |  1.17
Other   |            | 0.06413    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5394.00 ave        5394 max        5394 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333188.0 ave      333188 max      333188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333188
Ave neighs/atom = 166.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 = 272.930952108704, Press = -0.171891773554288
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  152000   -8041.0112   -8041.0112   -8110.6237   -8110.6237    269.40756    269.40756    21569.686    21569.686   -1406.4268   -1406.4268 
  153000   -8038.2404   -8038.2404    -8108.313    -8108.313    271.18797    271.18797    21593.533    21593.533   -2171.1174   -2171.1174 
Loop time of 31.6281 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.732 ns/day, 8.786 hours/ns, 31.617 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.069     | 31.069     | 31.069     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12546    | 0.12546    | 0.12546    |   0.0 |  0.40
Output  | 0.00015271 | 0.00015271 | 0.00015271 |   0.0 |  0.00
Modify  | 0.36954    | 0.36954    | 0.36954    |   0.0 |  1.17
Other   |            | 0.06385    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5398.00 ave        5398 max        5398 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333270.0 ave      333270 max      333270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333270
Ave neighs/atom = 166.63500
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 = 272.926134031748, Press = -0.536363546819568
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  153000   -8038.2404   -8038.2404    -8108.313    -8108.313    271.18797    271.18797    21593.533    21593.533   -2171.1174   -2171.1174 
  154000   -8041.5874   -8041.5874   -8111.3717   -8111.3717    270.07222    270.07222    21581.123    21581.123    -2278.389    -2278.389 
Loop time of 31.8091 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.716 ns/day, 8.836 hours/ns, 31.438 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    | 31.245     | 31.245     | 31.245     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1272     | 0.1272     | 0.1272     |   0.0 |  0.40
Output  | 0.00015658 | 0.00015658 | 0.00015658 |   0.0 |  0.00
Modify  | 0.37159    | 0.37159    | 0.37159    |   0.0 |  1.17
Other   |            | 0.06554    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5431.00 ave        5431 max        5431 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333076.0 ave      333076 max      333076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333076
Ave neighs/atom = 166.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 = 272.913920361509, Press = -0.803902894517171
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  154000   -8041.5874   -8041.5874   -8111.3717   -8111.3717    270.07222    270.07222    21581.123    21581.123    -2278.389    -2278.389 
  155000   -8036.7576   -8036.7576    -8107.746    -8107.746    274.73219    274.73219    21539.739    21539.739     1756.989     1756.989 
Loop time of 31.7118 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.725 ns/day, 8.809 hours/ns, 31.534 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.152     | 31.152     | 31.152     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12534    | 0.12534    | 0.12534    |   0.0 |  0.40
Output  | 0.00015456 | 0.00015456 | 0.00015456 |   0.0 |  0.00
Modify  | 0.37069    | 0.37069    | 0.37069    |   0.0 |  1.17
Other   |            | 0.06403    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5411.00 ave        5411 max        5411 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333320.0 ave      333320 max      333320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333320
Ave neighs/atom = 166.66000
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 = 272.907273830211, Press = -0.108747084858542
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  155000   -8036.7576   -8036.7576    -8107.746    -8107.746    274.73219    274.73219    21539.739    21539.739     1756.989     1756.989 
  156000   -8038.1405   -8038.1405   -8109.8316   -8109.8316    277.45176    277.45176    21554.393    21554.393     342.4176     342.4176 
Loop time of 32.0253 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.698 ns/day, 8.896 hours/ns, 31.225 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    | 31.453     | 31.453     | 31.453     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12867    | 0.12867    | 0.12867    |   0.0 |  0.40
Output  | 0.0001489  | 0.0001489  | 0.0001489  |   0.0 |  0.00
Modify  | 0.37828    | 0.37828    | 0.37828    |   0.0 |  1.18
Other   |            | 0.0652     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5412.00 ave        5412 max        5412 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333984.0 ave      333984 max      333984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333984
Ave neighs/atom = 166.99200
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 = 272.915497819681, Press = -0.0971195221052023
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  156000   -8038.1405   -8038.1405   -8109.8316   -8109.8316    277.45176    277.45176    21554.393    21554.393     342.4176     342.4176 
  157000   -8039.8736   -8039.8736   -8109.8438   -8109.8438    270.79195    270.79195    21575.189    21575.189   -387.37134   -387.37134 
Loop time of 31.9682 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.703 ns/day, 8.880 hours/ns, 31.281 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    | 31.396     | 31.396     | 31.396     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12853    | 0.12853    | 0.12853    |   0.0 |  0.40
Output  | 0.00015544 | 0.00015544 | 0.00015544 |   0.0 |  0.00
Modify  | 0.37966    | 0.37966    | 0.37966    |   0.0 |  1.19
Other   |            | 0.06392    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5419.00 ave        5419 max        5419 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333322.0 ave      333322 max      333322 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333322
Ave neighs/atom = 166.66100
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 = 272.930701112398, Press = -0.102714820262822
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  157000   -8039.8736   -8039.8736   -8109.8438   -8109.8438    270.79195    270.79195    21575.189    21575.189   -387.37134   -387.37134 
  158000   -8037.1114   -8037.1114   -8107.2082   -8107.2082    271.28193    271.28193    21547.409    21547.409    2797.9002    2797.9002 
Loop time of 31.5787 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.736 ns/day, 8.772 hours/ns, 31.667 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    | 31.018     | 31.018     | 31.018     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12668    | 0.12668    | 0.12668    |   0.0 |  0.40
Output  | 0.00019471 | 0.00019471 | 0.00019471 |   0.0 |  0.00
Modify  | 0.37014    | 0.37014    | 0.37014    |   0.0 |  1.17
Other   |            | 0.06389    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5408.00 ave        5408 max        5408 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333180.0 ave      333180 max      333180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333180
Ave neighs/atom = 166.59000
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 = 272.934836526546, Press = -0.0968668203134188
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  158000   -8037.1114   -8037.1114   -8107.2082   -8107.2082    271.28193    271.28193    21547.409    21547.409    2797.9002    2797.9002 
  159000   -8036.5308   -8036.5308   -8110.5837   -8110.5837    286.59219    286.59219    21573.069    21573.069   -2002.3879   -2002.3879 
Loop time of 32.5382 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.655 ns/day, 9.038 hours/ns, 30.733 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    | 31.966     | 31.966     | 31.966     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12814    | 0.12814    | 0.12814    |   0.0 |  0.39
Output  | 0.00016147 | 0.00016147 | 0.00016147 |   0.0 |  0.00
Modify  | 0.37959    | 0.37959    | 0.37959    |   0.0 |  1.17
Other   |            | 0.0645     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5397.00 ave        5397 max        5397 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333436.0 ave      333436 max      333436 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333436
Ave neighs/atom = 166.71800
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 = 272.940089783435, Press = -0.612828725541583
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  159000   -8036.5308   -8036.5308   -8110.5837   -8110.5837    286.59219    286.59219    21573.069    21573.069   -2002.3879   -2002.3879 
  160000   -8039.1992   -8039.1992   -8110.6744   -8110.6744    276.61644    276.61644    21569.315    21569.315    643.22447    643.22447 
Loop time of 31.4584 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.746 ns/day, 8.738 hours/ns, 31.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    | 30.899     | 30.899     | 30.899     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12615    | 0.12615    | 0.12615    |   0.0 |  0.40
Output  | 0.00015317 | 0.00015317 | 0.00015317 |   0.0 |  0.00
Modify  | 0.36858    | 0.36858    | 0.36858    |   0.0 |  1.17
Other   |            | 0.06444    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5412.00 ave        5412 max        5412 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333438.0 ave      333438 max      333438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333438
Ave neighs/atom = 166.71900
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 = 272.947054551794, Press = -0.260610003999471
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  160000   -8039.1992   -8039.1992   -8110.6744   -8110.6744    276.61644    276.61644    21569.315    21569.315    643.22447    643.22447 
  161000   -8036.0163   -8036.0163   -8107.9713   -8107.9713    278.47307    278.47307    21602.083    21602.083   -2567.2272   -2567.2272 
Loop time of 32.1484 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.688 ns/day, 8.930 hours/ns, 31.106 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    | 31.576     | 31.576     | 31.576     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12817    | 0.12817    | 0.12817    |   0.0 |  0.40
Output  | 0.00015693 | 0.00015693 | 0.00015693 |   0.0 |  0.00
Modify  | 0.37974    | 0.37974    | 0.37974    |   0.0 |  1.18
Other   |            | 0.0648     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5432.00 ave        5432 max        5432 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333350.0 ave      333350 max      333350 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333350
Ave neighs/atom = 166.67500
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 = 272.965354591978, Press = -0.827895458228088
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  161000   -8036.0163   -8036.0163   -8107.9713   -8107.9713    278.47307    278.47307    21602.083    21602.083   -2567.2272   -2567.2272 
  162000    -8040.325    -8040.325   -8110.3352   -8110.3352     270.9466     270.9466    21567.952    21567.952   -102.94794   -102.94794 
Loop time of 31.5813 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.736 ns/day, 8.773 hours/ns, 31.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    | 31.022     | 31.022     | 31.022     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12619    | 0.12619    | 0.12619    |   0.0 |  0.40
Output  | 0.00015713 | 0.00015713 | 0.00015713 |   0.0 |  0.00
Modify  | 0.36849    | 0.36849    | 0.36849    |   0.0 |  1.17
Other   |            | 0.06461    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5405.00 ave        5405 max        5405 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      332778.0 ave      332778 max      332778 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332778
Ave neighs/atom = 166.38900
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 = 272.965511316986, Press = -0.361960405524982
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  162000    -8040.325    -8040.325   -8110.3352   -8110.3352     270.9466     270.9466    21567.952    21567.952   -102.94794   -102.94794 
  163000   -8039.3663   -8039.3663   -8107.3153   -8107.3153    262.96948    262.96948    21537.497    21537.497    2697.9154    2697.9154 
Loop time of 31.247 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.765 ns/day, 8.680 hours/ns, 32.003 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    | 30.691     | 30.691     | 30.691     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12532    | 0.12532    | 0.12532    |   0.0 |  0.40
Output  | 0.00015649 | 0.00015649 | 0.00015649 |   0.0 |  0.00
Modify  | 0.36605    | 0.36605    | 0.36605    |   0.0 |  1.17
Other   |            | 0.06441    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5411.00 ave        5411 max        5411 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      333214.0 ave      333214 max      333214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333214
Ave neighs/atom = 166.60700
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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
21567.1546339561

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0