# 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.85487599670887*${_u_distance}
variable latticeconst_converted equal 2.85487599670887*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.85487599670887
Lattice spacing in x,y,z = 2.8548760 2.8548760 2.8548760
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.548760 28.548760 28.548760)
  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.548760 28.548760 28.548760)
  create_atoms CPU = 0.001 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_Wen_2021_FeH__MO_634187028437_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 23268.1442449223    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23268.1442449223/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 23268.1442449223/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 23268.1442449223/(1*1*${_u_distance})
variable      V0_metal equal 23268.1442449223/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 23268.1442449223*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23268.1442449223 Angstroms^3

# set the time step to 0.001 picoseconds
variable timestep_converted equal 0.001*${_u_time}
variable timestep_converted equal 0.001*1
timestep ${timestep_converted}
timestep 0.001

variable temp_converted equal 313.15*${_u_temperature}
variable temp_converted equal 313.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_634187028437_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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -7949.8814   -7949.8814   -8030.7966   -8030.7966       313.15       313.15    23268.144    23268.144    3714.3539    3714.3539 
    1000   -7864.8153   -7864.8153   -7939.0541   -7939.0541    287.31187    287.31187    23387.334    23387.334    451.46413    451.46413 
Loop time of 12.1947 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.085 ns/day, 3.387 hours/ns, 82.003 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    | 11.967     | 11.967     | 11.967     |   0.0 | 98.13
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044797   | 0.044797   | 0.044797   |   0.0 |  0.37
Output  | 0.00028638 | 0.00028638 | 0.00028638 |   0.0 |  0.00
Modify  | 0.15594    | 0.15594    | 0.15594    |   0.0 |  1.28
Other   |            | 0.02707    |            |       |  0.22

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:      272000.0 ave      272000 max      272000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 272000
Ave neighs/atom = 136.00000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -7864.8153   -7864.8153   -7939.0541   -7939.0541    287.31187    287.31187    23387.334    23387.334    451.46413    451.46413 
    2000   -7864.4346   -7864.4346   -7946.1836   -7946.1836     316.3771     316.3771    23389.663    23389.663    -315.1816    -315.1816 
Loop time of 12.4583 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.935 ns/day, 3.461 hours/ns, 80.268 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.238     | 12.238     | 12.238     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043362   | 0.043362   | 0.043362   |   0.0 |  0.35
Output  | 0.00013273 | 0.00013273 | 0.00013273 |   0.0 |  0.00
Modify  | 0.15136    | 0.15136    | 0.15136    |   0.0 |  1.21
Other   |            | 0.02491    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5427.00 ave        5427 max        5427 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      278568.0 ave      278568 max      278568 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278568
Ave neighs/atom = 139.28400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -7864.4346   -7864.4346   -7946.1836   -7946.1836     316.3771     316.3771    23389.663    23389.663    -315.1816    -315.1816 
    3000   -7865.4063   -7865.4063   -7944.2897   -7944.2897    305.28688    305.28688    23371.142    23371.142    1095.8085    1095.8085 
Loop time of 12.8127 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.743 ns/day, 3.559 hours/ns, 78.048 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    | 12.58      | 12.58      | 12.58      |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045796   | 0.045796   | 0.045796   |   0.0 |  0.36
Output  | 0.00021462 | 0.00021462 | 0.00021462 |   0.0 |  0.00
Modify  | 0.15988    | 0.15988    | 0.15988    |   0.0 |  1.25
Other   |            | 0.02722    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5449.00 ave        5449 max        5449 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277394.0 ave      277394 max      277394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277394
Ave neighs/atom = 138.69700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -7865.4063   -7865.4063   -7944.2897   -7944.2897    305.28688    305.28688    23371.142    23371.142    1095.8085    1095.8085 
    4000   -7863.9416   -7863.9416   -7946.2343   -7946.2343    318.48111    318.48111    23418.905    23418.905   -1851.1396   -1851.1396 
Loop time of 12.6058 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.854 ns/day, 3.502 hours/ns, 79.328 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.381     | 12.381     | 12.381     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044026   | 0.044026   | 0.044026   |   0.0 |  0.35
Output  | 0.0001217  | 0.0001217  | 0.0001217  |   0.0 |  0.00
Modify  | 0.15532    | 0.15532    | 0.15532    |   0.0 |  1.23
Other   |            | 0.02521    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5459.00 ave        5459 max        5459 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      278020.0 ave      278020 max      278020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278020
Ave neighs/atom = 139.01000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -7863.9416   -7863.9416   -7946.2343   -7946.2343    318.48111    318.48111    23418.905    23418.905   -1851.1396   -1851.1396 
    5000   -7865.7565   -7865.7565    -7946.758    -7946.758    313.48433    313.48433    23417.789    23417.789   -1537.6987   -1537.6987 
Loop time of 12.8517 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.723 ns/day, 3.570 hours/ns, 77.811 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.622     | 12.622     | 12.622     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044796   | 0.044796   | 0.044796   |   0.0 |  0.35
Output  | 9.2385e-05 | 9.2385e-05 | 9.2385e-05 |   0.0 |  0.00
Modify  | 0.15936    | 0.15936    | 0.15936    |   0.0 |  1.24
Other   |            | 0.02527    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5448.00 ave        5448 max        5448 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277202.0 ave      277202 max      277202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277202
Ave neighs/atom = 138.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 = 314.541216342077, Press = 1007.22763010505
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -7865.7565   -7865.7565    -7946.758    -7946.758    313.48433    313.48433    23417.789    23417.789   -1537.6987   -1537.6987 
    6000   -7863.2803   -7863.2803   -7944.0931   -7944.0931    312.75413    312.75413    23377.066    23377.066    856.35596    856.35596 
Loop time of 12.7874 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.757 ns/day, 3.552 hours/ns, 78.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    | 12.543     | 12.543     | 12.543     |   0.0 | 98.09
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045618   | 0.045618   | 0.045618   |   0.0 |  0.36
Output  | 0.00010732 | 0.00010732 | 0.00010732 |   0.0 |  0.00
Modify  | 0.17191    | 0.17191    | 0.17191    |   0.0 |  1.34
Other   |            | 0.02656    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5461.00 ave        5461 max        5461 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      276834.0 ave      276834 max      276834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 276834
Ave neighs/atom = 138.41700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.769802664066, Press = 50.9633858011552
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -7863.2803   -7863.2803   -7944.0931   -7944.0931    312.75413    312.75413    23377.066    23377.066    856.35596    856.35596 
    7000   -7864.6115   -7864.6115   -7946.1076   -7946.1076    315.39822    315.39822    23396.834    23396.834    59.463223    59.463223 
Loop time of 12.7372 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.783 ns/day, 3.538 hours/ns, 78.510 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.504     | 12.504     | 12.504     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044638   | 0.044638   | 0.044638   |   0.0 |  0.35
Output  | 9.1704e-05 | 9.1704e-05 | 9.1704e-05 |   0.0 |  0.00
Modify  | 0.16324    | 0.16324    | 0.16324    |   0.0 |  1.28
Other   |            | 0.0249     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5448.00 ave        5448 max        5448 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      278116.0 ave      278116 max      278116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278116
Ave neighs/atom = 139.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 = 312.973194248793, Press = 12.6002424413793
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -7864.6115   -7864.6115   -7946.1076   -7946.1076    315.39822    315.39822    23396.834    23396.834    59.463223    59.463223 
    8000   -7870.6434   -7870.6434   -7947.6101   -7947.6101    297.86921    297.86921    23398.013    23398.013   -925.65804   -925.65804 
Loop time of 12.5962 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.859 ns/day, 3.499 hours/ns, 79.389 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.368     | 12.368     | 12.368     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043696   | 0.043696   | 0.043696   |   0.0 |  0.35
Output  | 6.5056e-05 | 6.5056e-05 | 6.5056e-05 |   0.0 |  0.00
Modify  | 0.15964    | 0.15964    | 0.15964    |   0.0 |  1.27
Other   |            | 0.02479    |            |       |  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:      277328.0 ave      277328 max      277328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277328
Ave neighs/atom = 138.66400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.2600634379, Press = 24.888047113713
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -7870.6434   -7870.6434   -7947.6101   -7947.6101    297.86921    297.86921    23398.013    23398.013   -925.65804   -925.65804 
    9000   -7863.2265   -7863.2265   -7946.6529   -7946.6529    322.86876    322.86876    23408.619    23408.619   -756.96416   -756.96416 
Loop time of 12.7126 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.796 ns/day, 3.531 hours/ns, 78.662 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.48      | 12.48      | 12.48      |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044564   | 0.044564   | 0.044564   |   0.0 |  0.35
Output  | 0.00018942 | 0.00018942 | 0.00018942 |   0.0 |  0.00
Modify  | 0.16218    | 0.16218    | 0.16218    |   0.0 |  1.28
Other   |            | 0.02533    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5457.00 ave        5457 max        5457 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277496.0 ave      277496 max      277496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277496
Ave neighs/atom = 138.74800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.192962271677, Press = 16.31452362795
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -7863.2265   -7863.2265   -7946.6529   -7946.6529    322.86876    322.86876    23408.619    23408.619   -756.96416   -756.96416 
   10000   -7867.9561   -7867.9561   -7948.5222   -7948.5222    311.79912    311.79912     23381.47     23381.47    513.33184    513.33184 
Loop time of 12.6499 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.830 ns/day, 3.514 hours/ns, 79.052 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.422     | 12.422     | 12.422     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044131   | 0.044131   | 0.044131   |   0.0 |  0.35
Output  | 6.4988e-05 | 6.4988e-05 | 6.4988e-05 |   0.0 |  0.00
Modify  | 0.15961    | 0.15961    | 0.15961    |   0.0 |  1.26
Other   |            | 0.0245     |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5462.00 ave        5462 max        5462 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277008.0 ave      277008 max      277008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277008
Ave neighs/atom = 138.50400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.176793487383, Press = 19.7620882068129
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -7867.9561   -7867.9561   -7948.5222   -7948.5222    311.79912    311.79912     23381.47     23381.47    513.33184    513.33184 
   11000   -7865.5315   -7865.5315   -7946.3968   -7946.3968    312.95715    312.95715    23370.751    23370.751    1563.1928    1563.1928 
Loop time of 12.6696 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.819 ns/day, 3.519 hours/ns, 78.929 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    | 12.439     | 12.439     | 12.439     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044091   | 0.044091   | 0.044091   |   0.0 |  0.35
Output  | 0.00010289 | 0.00010289 | 0.00010289 |   0.0 |  0.00
Modify  | 0.16177    | 0.16177    | 0.16177    |   0.0 |  1.28
Other   |            | 0.02509    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5459.00 ave        5459 max        5459 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277452.0 ave      277452 max      277452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277452
Ave neighs/atom = 138.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 = 312.587278641678, Press = 6.76923378401017
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -7865.5315   -7865.5315   -7946.3968   -7946.3968    312.95715    312.95715    23370.751    23370.751    1563.1928    1563.1928 
   12000   -7865.9929   -7865.9929   -7944.2809   -7944.2809    302.98264    302.98264    23409.238    23409.238   -1034.4632   -1034.4632 
Loop time of 13.2729 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.509 ns/day, 3.687 hours/ns, 75.341 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 13.025     | 13.025     | 13.025     |   0.0 | 98.13
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046974   | 0.046974   | 0.046974   |   0.0 |  0.35
Output  | 0.00010888 | 0.00010888 | 0.00010888 |   0.0 |  0.00
Modify  | 0.17387    | 0.17387    | 0.17387    |   0.0 |  1.31
Other   |            | 0.02726    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5449.00 ave        5449 max        5449 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277794.0 ave      277794 max      277794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277794
Ave neighs/atom = 138.89700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.938638849373, Press = 0.526785012552574
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -7865.9929   -7865.9929   -7944.2809   -7944.2809    302.98264    302.98264    23409.238    23409.238   -1034.4632   -1034.4632 
   13000   -7859.6068   -7859.6068   -7942.8722   -7942.8722    322.24558    322.24558    23434.581    23434.581   -2468.6571   -2468.6571 
Loop time of 13.0024 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.645 ns/day, 3.612 hours/ns, 76.909 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.749     | 12.749     | 12.749     |   0.0 | 98.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.058236   | 0.058236   | 0.058236   |   0.0 |  0.45
Output  | 9.7901e-05 | 9.7901e-05 | 9.7901e-05 |   0.0 |  0.00
Modify  | 0.16803    | 0.16803    | 0.16803    |   0.0 |  1.29
Other   |            | 0.02658    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5449.00 ave        5449 max        5449 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277188.0 ave      277188 max      277188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277188
Ave neighs/atom = 138.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 = 313.302978604286, Press = 13.7562293960029
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -7859.6068   -7859.6068   -7942.8722   -7942.8722    322.24558    322.24558    23434.581    23434.581   -2468.6571   -2468.6571 
   14000   -7864.9641   -7864.9641   -7947.3823   -7947.3823    318.96706    318.96706    23368.455    23368.455    1308.7678    1308.7678 
Loop time of 12.9495 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.672 ns/day, 3.597 hours/ns, 77.223 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.711     | 12.711     | 12.711     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045325   | 0.045325   | 0.045325   |   0.0 |  0.35
Output  | 0.00010095 | 0.00010095 | 0.00010095 |   0.0 |  0.00
Modify  | 0.1678     | 0.1678     | 0.1678     |   0.0 |  1.30
Other   |            | 0.0255     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5443.00 ave        5443 max        5443 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277266.0 ave      277266 max      277266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277266
Ave neighs/atom = 138.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 = 313.399415903504, Press = 11.3196664313689
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -7864.9641   -7864.9641   -7947.3823   -7947.3823    318.96706    318.96706    23368.455    23368.455    1308.7678    1308.7678 
   15000    -7867.724    -7867.724   -7947.8743   -7947.8743     310.1899     310.1899    23381.303    23381.303    362.28879    362.28879 
Loop time of 12.6753 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.816 ns/day, 3.521 hours/ns, 78.894 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    | 12.445     | 12.445     | 12.445     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04417    | 0.04417    | 0.04417    |   0.0 |  0.35
Output  | 9.7258e-05 | 9.7258e-05 | 9.7258e-05 |   0.0 |  0.00
Modify  | 0.16165    | 0.16165    | 0.16165    |   0.0 |  1.28
Other   |            | 0.02481    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5460.00 ave        5460 max        5460 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277828.0 ave      277828 max      277828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277828
Ave neighs/atom = 138.91400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.465684132164, Press = 3.56505431750955
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000    -7867.724    -7867.724   -7947.8743   -7947.8743     310.1899     310.1899    23381.303    23381.303    362.28879    362.28879 
   16000   -7868.2152   -7868.2152     -7948.22     -7948.22    309.62672    309.62672    23399.877    23399.877   -560.97071   -560.97071 
Loop time of 12.9995 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.646 ns/day, 3.611 hours/ns, 76.926 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.756     | 12.756     | 12.756     |   0.0 | 98.13
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045887   | 0.045887   | 0.045887   |   0.0 |  0.35
Output  | 9.3737e-05 | 9.3737e-05 | 9.3737e-05 |   0.0 |  0.00
Modify  | 0.1706     | 0.1706     | 0.1706     |   0.0 |  1.31
Other   |            | 0.02645    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5457.00 ave        5457 max        5457 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277318.0 ave      277318 max      277318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277318
Ave neighs/atom = 138.65900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.424315168867, Press = 3.11001500969595
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -7868.2152   -7868.2152     -7948.22     -7948.22    309.62672    309.62672    23399.877    23399.877   -560.97071   -560.97071 
   17000   -7864.3049   -7864.3049   -7944.7819   -7944.7819    311.45434    311.45434    23391.359    23391.359    248.05297    248.05297 
Loop time of 13.21 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.540 ns/day, 3.669 hours/ns, 75.700 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.964     | 12.964     | 12.964     |   0.0 | 98.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046544   | 0.046544   | 0.046544   |   0.0 |  0.35
Output  | 9.4969e-05 | 9.4969e-05 | 9.4969e-05 |   0.0 |  0.00
Modify  | 0.17332    | 0.17332    | 0.17332    |   0.0 |  1.31
Other   |            | 0.02632    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5445.00 ave        5445 max        5445 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277058.0 ave      277058 max      277058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277058
Ave neighs/atom = 138.52900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.130384300163, Press = 8.93585569401906
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -7864.3049   -7864.3049   -7944.7819   -7944.7819    311.45434    311.45434    23391.359    23391.359    248.05297    248.05297 
   18000   -7867.0652   -7867.0652   -7948.1782   -7948.1782    313.91557    313.91557    23343.082    23343.082    3187.3261    3187.3261 
Loop time of 12.6434 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.834 ns/day, 3.512 hours/ns, 79.092 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.416     | 12.416     | 12.416     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043479   | 0.043479   | 0.043479   |   0.0 |  0.34
Output  | 9.1193e-05 | 9.1193e-05 | 9.1193e-05 |   0.0 |  0.00
Modify  | 0.15954    | 0.15954    | 0.15954    |   0.0 |  1.26
Other   |            | 0.02438    |            |       |  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:      277588.0 ave      277588 max      277588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277588
Ave neighs/atom = 138.79400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.102831008895, Press = 4.21428953469153
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -7867.0652   -7867.0652   -7948.1782   -7948.1782    313.91557    313.91557    23343.082    23343.082    3187.3261    3187.3261 
   19000   -7860.6902   -7860.6902   -7943.6182   -7943.6182     320.9399     320.9399    23403.247    23403.247   -627.10747   -627.10747 
Loop time of 13.1835 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.554 ns/day, 3.662 hours/ns, 75.853 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    | 12.939     | 12.939     | 12.939     |   0.0 | 98.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047105   | 0.047105   | 0.047105   |   0.0 |  0.36
Output  | 0.00072416 | 0.00072416 | 0.00072416 |   0.0 |  0.01
Modify  | 0.17126    | 0.17126    | 0.17126    |   0.0 |  1.30
Other   |            | 0.02587    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5463.00 ave        5463 max        5463 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277680.0 ave      277680 max      277680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277680
Ave neighs/atom = 138.84000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.286992574038, Press = -1.63478008759418
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -7860.6902   -7860.6902   -7943.6182   -7943.6182     320.9399     320.9399    23403.247    23403.247   -627.10747   -627.10747 
   20000   -7866.0946   -7866.0946   -7946.6025   -7946.6025    311.57399    311.57399    23398.068    23398.068   -666.74407   -666.74407 
Loop time of 12.5967 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.859 ns/day, 3.499 hours/ns, 79.386 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.368     | 12.368     | 12.368     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043988   | 0.043988   | 0.043988   |   0.0 |  0.35
Output  | 9.5597e-05 | 9.5597e-05 | 9.5597e-05 |   0.0 |  0.00
Modify  | 0.16001    | 0.16001    | 0.16001    |   0.0 |  1.27
Other   |            | 0.02472    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5441.00 ave        5441 max        5441 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277558.0 ave      277558 max      277558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277558
Ave neighs/atom = 138.77900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.300301172467, Press = 4.08498181709132
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -7866.0946   -7866.0946   -7946.6025   -7946.6025    311.57399    311.57399    23398.068    23398.068   -666.74407   -666.74407 
   21000   -7862.2996   -7862.2996   -7944.8052   -7944.8052    319.30537    319.30537    23386.685    23386.685    748.61203    748.61203 
Loop time of 12.4029 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.966 ns/day, 3.445 hours/ns, 80.626 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.182     | 12.182     | 12.182     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042889   | 0.042889   | 0.042889   |   0.0 |  0.35
Output  | 9.0409e-05 | 9.0409e-05 | 9.0409e-05 |   0.0 |  0.00
Modify  | 0.15417    | 0.15417    | 0.15417    |   0.0 |  1.24
Other   |            | 0.02362    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5448.00 ave        5448 max        5448 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277308.0 ave      277308 max      277308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277308
Ave neighs/atom = 138.65400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.427685881021, Press = 3.155457650449
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -7862.2996   -7862.2996   -7944.8052   -7944.8052    319.30537    319.30537    23386.685    23386.685    748.61203    748.61203 
   22000    -7865.968    -7865.968   -7944.8518   -7944.8518    305.28836    305.28836    23390.923    23390.923     243.7822     243.7822 
Loop time of 12.8691 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.714 ns/day, 3.575 hours/ns, 77.705 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.634     | 12.634     | 12.634     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.045645   | 0.045645   | 0.045645   |   0.0 |  0.35
Output  | 9.4245e-05 | 9.4245e-05 | 9.4245e-05 |   0.0 |  0.00
Modify  | 0.16404    | 0.16404    | 0.16404    |   0.0 |  1.27
Other   |            | 0.0249     |            |       |  0.19

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:      277576.0 ave      277576 max      277576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277576
Ave neighs/atom = 138.78800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.447605361703, Press = 1.50083777315138
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000    -7865.968    -7865.968   -7944.8518   -7944.8518    305.28836    305.28836    23390.923    23390.923     243.7822     243.7822 
   23000   -7863.5136   -7863.5136   -7946.4028   -7946.4028    320.78969    320.78969    23416.774    23416.774   -1643.0907   -1643.0907 
Loop time of 12.525 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.898 ns/day, 3.479 hours/ns, 79.840 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.299     | 12.299     | 12.299     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04367    | 0.04367    | 0.04367    |   0.0 |  0.35
Output  | 8.7111e-05 | 8.7111e-05 | 8.7111e-05 |   0.0 |  0.00
Modify  | 0.15786    | 0.15786    | 0.15786    |   0.0 |  1.26
Other   |            | 0.02427    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5442.00 ave        5442 max        5442 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277586.0 ave      277586 max      277586 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277586
Ave neighs/atom = 138.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 = 313.426068014919, Press = 3.40408609138013
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -7863.5136   -7863.5136   -7946.4028   -7946.4028    320.78969    320.78969    23416.774    23416.774   -1643.0907   -1643.0907 
   24000   -7863.8146   -7863.8146   -7941.7016   -7941.7016    301.43087    301.43087    23377.034    23377.034    1297.3021    1297.3021 
Loop time of 12.6325 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.840 ns/day, 3.509 hours/ns, 79.161 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.403     | 12.403     | 12.403     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044043   | 0.044043   | 0.044043   |   0.0 |  0.35
Output  | 0.00016877 | 0.00016877 | 0.00016877 |   0.0 |  0.00
Modify  | 0.16063    | 0.16063    | 0.16063    |   0.0 |  1.27
Other   |            | 0.02444    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5448.00 ave        5448 max        5448 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277252.0 ave      277252 max      277252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277252
Ave neighs/atom = 138.62600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.412700721133, Press = 4.8500141021221
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -7863.8146   -7863.8146   -7941.7016   -7941.7016    301.43087    301.43087    23377.034    23377.034    1297.3021    1297.3021 
   25000    -7864.253    -7864.253   -7945.9348   -7945.9348    316.11717    316.11717    23385.944    23385.944    506.98329    506.98329 
Loop time of 12.642 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.834 ns/day, 3.512 hours/ns, 79.102 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    | 12.409     | 12.409     | 12.409     |   0.0 | 98.15
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043762   | 0.043762   | 0.043762   |   0.0 |  0.35
Output  | 9.6e-05    | 9.6e-05    | 9.6e-05    |   0.0 |  0.00
Modify  | 0.16514    | 0.16514    | 0.16514    |   0.0 |  1.31
Other   |            | 0.02429    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5436.00 ave        5436 max        5436 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      278000.0 ave      278000 max      278000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278000
Ave neighs/atom = 139.00000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.556331613508, Press = -0.846189065121615
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000    -7864.253    -7864.253   -7945.9348   -7945.9348    316.11717    316.11717    23385.944    23385.944    506.98329    506.98329 
   26000   -7862.4706   -7862.4706   -7944.8063   -7944.8063    318.64745    318.64745    23440.703    23440.703   -3032.5561   -3032.5561 
Loop time of 12.7022 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.802 ns/day, 3.528 hours/ns, 78.727 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.473     | 12.473     | 12.473     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04415    | 0.04415    | 0.04415    |   0.0 |  0.35
Output  | 8.7304e-05 | 8.7304e-05 | 8.7304e-05 |   0.0 |  0.00
Modify  | 0.16094    | 0.16094    | 0.16094    |   0.0 |  1.27
Other   |            | 0.02436    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5441.00 ave        5441 max        5441 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277362.0 ave      277362 max      277362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277362
Ave neighs/atom = 138.68100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.58843720126, Press = 0.133319356435479
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -7862.4706   -7862.4706   -7944.8063   -7944.8063    318.64745    318.64745    23440.703    23440.703   -3032.5561   -3032.5561 
   27000   -7867.1359   -7867.1359   -7946.4435   -7946.4435    306.92868    306.92868    23387.527    23387.527    486.81885    486.81885 
Loop time of 12.1655 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.102 ns/day, 3.379 hours/ns, 82.200 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.952     | 11.952     | 11.952     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041728   | 0.041728   | 0.041728   |   0.0 |  0.34
Output  | 0.0001786  | 0.0001786  | 0.0001786  |   0.0 |  0.00
Modify  | 0.14848    | 0.14848    | 0.14848    |   0.0 |  1.22
Other   |            | 0.02275    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5449.00 ave        5449 max        5449 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277176.0 ave      277176 max      277176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277176
Ave neighs/atom = 138.58800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.581410766726, Press = 5.42469174705248
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -7867.1359   -7867.1359   -7946.4435   -7946.4435    306.92868    306.92868    23387.527    23387.527    486.81885    486.81885 
   28000   -7865.8522   -7865.8522   -7945.1515   -7945.1515     306.8966     306.8966    23377.045    23377.045    882.54415    882.54415 
Loop time of 12.2696 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.042 ns/day, 3.408 hours/ns, 81.502 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.054     | 12.054     | 12.054     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042255   | 0.042255   | 0.042255   |   0.0 |  0.34
Output  | 9.9526e-05 | 9.9526e-05 | 9.9526e-05 |   0.0 |  0.00
Modify  | 0.14999    | 0.14999    | 0.14999    |   0.0 |  1.22
Other   |            | 0.02322    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5437.00 ave        5437 max        5437 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277506.0 ave      277506 max      277506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277506
Ave neighs/atom = 138.75300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.533893279819, Press = 2.01292642240406
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -7865.8522   -7865.8522   -7945.1515   -7945.1515     306.8966     306.8966    23377.045    23377.045    882.54415    882.54415 
   29000   -7861.1513   -7861.1513   -7943.0949   -7943.0949    317.13048    317.13048    23407.124    23407.124   -633.04558   -633.04558 
Loop time of 12.4367 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.947 ns/day, 3.455 hours/ns, 80.407 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.215     | 12.215     | 12.215     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043086   | 0.043086   | 0.043086   |   0.0 |  0.35
Output  | 0.00019902 | 0.00019902 | 0.00019902 |   0.0 |  0.00
Modify  | 0.15416    | 0.15416    | 0.15416    |   0.0 |  1.24
Other   |            | 0.02426    |            |       |  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:      277988.0 ave      277988 max      277988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277988
Ave neighs/atom = 138.99400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.455557364027, Press = 1.70978224942034
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -7861.1513   -7861.1513   -7943.0949   -7943.0949    317.13048    317.13048    23407.124    23407.124   -633.04558   -633.04558 
   30000   -7865.3571   -7865.3571   -7946.4333   -7946.4333    313.77343    313.77343    23394.693    23394.693    220.09744    220.09744 
Loop time of 12.2008 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.082 ns/day, 3.389 hours/ns, 81.962 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.987     | 11.987     | 11.987     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041917   | 0.041917   | 0.041917   |   0.0 |  0.34
Output  | 9.5428e-05 | 9.5428e-05 | 9.5428e-05 |   0.0 |  0.00
Modify  | 0.14891    | 0.14891    | 0.14891    |   0.0 |  1.22
Other   |            | 0.02276    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5446.00 ave        5446 max        5446 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277534.0 ave      277534 max      277534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277534
Ave neighs/atom = 138.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 = 313.551403709037, Press = 3.3946677827858
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -7865.3571   -7865.3571   -7946.4333   -7946.4333    313.77343    313.77343    23394.693    23394.693    220.09744    220.09744 
   31000   -7861.7564   -7861.7564   -7943.8528   -7943.8528    317.72166    317.72166    23355.375    23355.375    2857.9926    2857.9926 
Loop time of 12.4413 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.945 ns/day, 3.456 hours/ns, 80.377 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.22      | 12.22      | 12.22      |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043062   | 0.043062   | 0.043062   |   0.0 |  0.35
Output  | 9.0398e-05 | 9.0398e-05 | 9.0398e-05 |   0.0 |  0.00
Modify  | 0.15481    | 0.15481    | 0.15481    |   0.0 |  1.24
Other   |            | 0.02362    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5449.00 ave        5449 max        5449 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277154.0 ave      277154 max      277154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277154
Ave neighs/atom = 138.57700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.545636728832, Press = 4.39132625797084
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -7861.7564   -7861.7564   -7943.8528   -7943.8528    317.72166    317.72166    23355.375    23355.375    2857.9926    2857.9926 
   32000    -7865.037    -7865.037   -7944.5438   -7944.5438    307.69966    307.69966    23354.958    23354.958    2571.5035    2571.5035 
Loop time of 12.3479 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.997 ns/day, 3.430 hours/ns, 80.986 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.13      | 12.13      | 12.13      |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042745   | 0.042745   | 0.042745   |   0.0 |  0.35
Output  | 9.7276e-05 | 9.7276e-05 | 9.7276e-05 |   0.0 |  0.00
Modify  | 0.15172    | 0.15172    | 0.15172    |   0.0 |  1.23
Other   |            | 0.02297    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5446.00 ave        5446 max        5446 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      278318.0 ave      278318 max      278318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278318
Ave neighs/atom = 139.15900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.569969512495, Press = -0.105987436377331
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000    -7865.037    -7865.037   -7944.5438   -7944.5438    307.69966    307.69966    23354.958    23354.958    2571.5035    2571.5035 
   33000   -7870.0411   -7870.0411    -7947.744    -7947.744     300.7181     300.7181    23408.647    23408.647   -1267.1356   -1267.1356 
Loop time of 12.4429 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.944 ns/day, 3.456 hours/ns, 80.367 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    | 12.222     | 12.222     | 12.222     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042796   | 0.042796   | 0.042796   |   0.0 |  0.34
Output  | 9.0402e-05 | 9.0402e-05 | 9.0402e-05 |   0.0 |  0.00
Modify  | 0.15424    | 0.15424    | 0.15424    |   0.0 |  1.24
Other   |            | 0.02411    |            |       |  0.19

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:      278024.0 ave      278024 max      278024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278024
Ave neighs/atom = 139.01200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.479084741645, Press = 0.794465503735447
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -7870.0411   -7870.0411    -7947.744    -7947.744     300.7181     300.7181    23408.647    23408.647   -1267.1356   -1267.1356 
   34000   -7864.1921   -7864.1921   -7946.6394   -7946.6394    319.07965    319.07965    23402.786    23402.786   -581.25307   -581.25307 
Loop time of 12.4603 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.934 ns/day, 3.461 hours/ns, 80.255 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.239     | 12.239     | 12.239     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.043185   | 0.043185   | 0.043185   |   0.0 |  0.35
Output  | 9.4657e-05 | 9.4657e-05 | 9.4657e-05 |   0.0 |  0.00
Modify  | 0.15464    | 0.15464    | 0.15464    |   0.0 |  1.24
Other   |            | 0.02369    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5451.00 ave        5451 max        5451 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277030.0 ave      277030 max      277030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277030
Ave neighs/atom = 138.51500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.447072791278, Press = 4.06947552281209
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -7864.1921   -7864.1921   -7946.6394   -7946.6394    319.07965    319.07965    23402.786    23402.786   -581.25307   -581.25307 
   35000   -7863.5382   -7863.5382   -7946.1645   -7946.1645    319.77224    319.77224    23361.747    23361.747    2391.6828    2391.6828 
Loop time of 12.6466 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.832 ns/day, 3.513 hours/ns, 79.073 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.418     | 12.418     | 12.418     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04398    | 0.04398    | 0.04398    |   0.0 |  0.35
Output  | 5.8226e-05 | 5.8226e-05 | 5.8226e-05 |   0.0 |  0.00
Modify  | 0.16059    | 0.16059    | 0.16059    |   0.0 |  1.27
Other   |            | 0.02389    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5442.00 ave        5442 max        5442 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277164.0 ave      277164 max      277164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277164
Ave neighs/atom = 138.58200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.436915848777, Press = 1.97573795531811
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -7863.5382   -7863.5382   -7946.1645   -7946.1645    319.77224    319.77224    23361.747    23361.747    2391.6828    2391.6828 
   36000   -7864.7657   -7864.7657   -7945.2436   -7945.2436    311.45779    311.45779    23375.596    23375.596     1207.728     1207.728 
Loop time of 12.6892 on 1 procs for 1000 steps with 2000 atoms

Performance: 6.809 ns/day, 3.525 hours/ns, 78.807 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    | 12.457     | 12.457     | 12.457     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.044166   | 0.044166   | 0.044166   |   0.0 |  0.35
Output  | 8.6757e-05 | 8.6757e-05 | 8.6757e-05 |   0.0 |  0.00
Modify  | 0.16181    | 0.16181    | 0.16181    |   0.0 |  1.28
Other   |            | 0.0257     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5452.00 ave        5452 max        5452 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277678.0 ave      277678 max      277678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277678
Ave neighs/atom = 138.83900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.527469748045, Press = -0.526772613271872
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -7864.7657   -7864.7657   -7945.2436   -7945.2436    311.45779    311.45779    23375.596    23375.596     1207.728     1207.728 
   37000   -7862.7857   -7862.7857    -7945.626    -7945.626    320.60057    320.60057    23440.145    23440.145   -3253.9968   -3253.9968 
Loop time of 12.2604 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.047 ns/day, 3.406 hours/ns, 81.564 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.046     | 12.046     | 12.046     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042203   | 0.042203   | 0.042203   |   0.0 |  0.34
Output  | 9.0327e-05 | 9.0327e-05 | 9.0327e-05 |   0.0 |  0.00
Modify  | 0.14973    | 0.14973    | 0.14973    |   0.0 |  1.22
Other   |            | 0.02273    |            |       |  0.19

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:      277940.0 ave      277940 max      277940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277940
Ave neighs/atom = 138.97000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.54421715592, Press = 1.0267346736855
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -7862.7857   -7862.7857    -7945.626    -7945.626    320.60057    320.60057    23440.145    23440.145   -3253.9968   -3253.9968 
   38000   -7863.8708   -7863.8708   -7945.5813   -7945.5813    316.22788    316.22788    23406.014    23406.014   -607.75121   -607.75121 
Loop time of 12.23 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.065 ns/day, 3.397 hours/ns, 81.766 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.015     | 12.015     | 12.015     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042169   | 0.042169   | 0.042169   |   0.0 |  0.34
Output  | 8.603e-05  | 8.603e-05  | 8.603e-05  |   0.0 |  0.00
Modify  | 0.1499     | 0.1499     | 0.1499     |   0.0 |  1.23
Other   |            | 0.02322    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5450.00 ave        5450 max        5450 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      276946.0 ave      276946 max      276946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 276946
Ave neighs/atom = 138.47300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.641278784747, Press = 3.97843269994142
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -7863.8708   -7863.8708   -7945.5813   -7945.5813    316.22788    316.22788    23406.014    23406.014   -607.75121   -607.75121 
   39000   -7864.7487   -7864.7487   -7945.9914   -7945.9914    314.41752    314.41752    23352.544    23352.544     2873.625     2873.625 
Loop time of 12.1828 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.092 ns/day, 3.384 hours/ns, 82.083 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.971     | 11.971     | 11.971     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041638   | 0.041638   | 0.041638   |   0.0 |  0.34
Output  | 8.8272e-05 | 8.8272e-05 | 8.8272e-05 |   0.0 |  0.00
Modify  | 0.14745    | 0.14745    | 0.14745    |   0.0 |  1.21
Other   |            | 0.02224    |            |       |  0.18

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5455.00 ave        5455 max        5455 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277422.0 ave      277422 max      277422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277422
Ave neighs/atom = 138.71100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.658818102193, Press = 1.8631221339489
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -7864.7487   -7864.7487   -7945.9914   -7945.9914    314.41752    314.41752    23352.544    23352.544     2873.625     2873.625 
   40000   -7867.2896   -7867.2896   -7947.0384   -7947.0384    308.63584    308.63584    23409.266    23409.266   -1095.4817   -1095.4817 
Loop time of 12.1954 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.085 ns/day, 3.388 hours/ns, 81.998 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.983     | 11.983     | 11.983     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041824   | 0.041824   | 0.041824   |   0.0 |  0.34
Output  | 0.00010414 | 0.00010414 | 0.00010414 |   0.0 |  0.00
Modify  | 0.14836    | 0.14836    | 0.14836    |   0.0 |  1.22
Other   |            | 0.02248    |            |       |  0.18

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5450.00 ave        5450 max        5450 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277938.0 ave      277938 max      277938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277938
Ave neighs/atom = 138.96900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.699002182783, Press = -1.28127330680458
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -7867.2896   -7867.2896   -7947.0384   -7947.0384    308.63584    308.63584    23409.266    23409.266   -1095.4817   -1095.4817 
   41000   -7860.9206   -7860.9206   -7945.9195   -7945.9195    328.95427    328.95427    23419.189    23419.189    -1523.597    -1523.597 
Loop time of 12.318 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.014 ns/day, 3.422 hours/ns, 81.182 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 12.101     | 12.101     | 12.101     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042041   | 0.042041   | 0.042041   |   0.0 |  0.34
Output  | 8.6318e-05 | 8.6318e-05 | 8.6318e-05 |   0.0 |  0.00
Modify  | 0.15163    | 0.15163    | 0.15163    |   0.0 |  1.23
Other   |            | 0.02311    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5436.00 ave        5436 max        5436 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277166.0 ave      277166 max      277166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277166
Ave neighs/atom = 138.58300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.708006452048, Press = 2.15398087637496
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -7860.9206   -7860.9206   -7945.9195   -7945.9195    328.95427    328.95427    23419.189    23419.189    -1523.597    -1523.597 
   42000   -7865.1968   -7865.1968   -7945.9475   -7945.9475    312.51338    312.51338     23375.79     23375.79    1308.9616    1308.9616 
Loop time of 12.0833 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.150 ns/day, 3.356 hours/ns, 82.759 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.873     | 11.873     | 11.873     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04154    | 0.04154    | 0.04154    |   0.0 |  0.34
Output  | 5.9787e-05 | 5.9787e-05 | 5.9787e-05 |   0.0 |  0.00
Modify  | 0.14647    | 0.14647    | 0.14647    |   0.0 |  1.21
Other   |            | 0.0226     |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5435.00 ave        5435 max        5435 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277274.0 ave      277274 max      277274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277274
Ave neighs/atom = 138.63700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.715109292923, Press = 2.79984687157588
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -7865.1968   -7865.1968   -7945.9475   -7945.9475    312.51338    312.51338     23375.79     23375.79    1308.9616    1308.9616 
   43000   -7864.6954   -7864.6954    -7946.955    -7946.955    318.35326    318.35326      23382.4      23382.4    1085.5262    1085.5262 
Loop time of 12.1023 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.139 ns/day, 3.362 hours/ns, 82.629 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.891     | 11.891     | 11.891     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041355   | 0.041355   | 0.041355   |   0.0 |  0.34
Output  | 8.3261e-05 | 8.3261e-05 | 8.3261e-05 |   0.0 |  0.00
Modify  | 0.14712    | 0.14712    | 0.14712    |   0.0 |  1.22
Other   |            | 0.02256    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5455.00 ave        5455 max        5455 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277426.0 ave      277426 max      277426 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277426
Ave neighs/atom = 138.71300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.712467645558, Press = 0.699205592716
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -7864.6954   -7864.6954    -7946.955    -7946.955    318.35326    318.35326      23382.4      23382.4    1085.5262    1085.5262 
   44000   -7867.1406   -7867.1406   -7945.6798   -7945.6798    303.95488    303.95488    23404.111    23404.111   -635.93385   -635.93385 
Loop time of 11.9654 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.221 ns/day, 3.324 hours/ns, 83.574 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.76      | 11.76      | 11.76      |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040689   | 0.040689   | 0.040689   |   0.0 |  0.34
Output  | 8.7765e-05 | 8.7765e-05 | 8.7765e-05 |   0.0 |  0.00
Modify  | 0.14314    | 0.14314    | 0.14314    |   0.0 |  1.20
Other   |            | 0.02195    |            |       |  0.18

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5448.00 ave        5448 max        5448 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277282.0 ave      277282 max      277282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277282
Ave neighs/atom = 138.64100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.672996206263, Press = 0.288850821753004
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -7867.1406   -7867.1406   -7945.6798   -7945.6798    303.95488    303.95488    23404.111    23404.111   -635.93385   -635.93385 
   45000    -7863.001    -7863.001   -7946.6062   -7946.6062    323.56098    323.56098    23387.788    23387.788     482.6052     482.6052 
Loop time of 11.9015 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.260 ns/day, 3.306 hours/ns, 84.023 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.696     | 11.696     | 11.696     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040633   | 0.040633   | 0.040633   |   0.0 |  0.34
Output  | 0.00018057 | 0.00018057 | 0.00018057 |   0.0 |  0.00
Modify  | 0.14309    | 0.14309    | 0.14309    |   0.0 |  1.20
Other   |            | 0.02201    |            |       |  0.18

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5455.00 ave        5455 max        5455 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277406.0 ave      277406 max      277406 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277406
Ave neighs/atom = 138.70300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.649277292263, Press = 1.80931006486369
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000    -7863.001    -7863.001   -7946.6062   -7946.6062    323.56098    323.56098    23387.788    23387.788     482.6052     482.6052 
   46000   -7864.5495   -7864.5495   -7944.2277   -7944.2277    308.36296    308.36296    23399.538    23399.538   -271.92713   -271.92713 
Loop time of 11.5894 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.455 ns/day, 3.219 hours/ns, 86.286 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.381     | 11.381     | 11.381     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040816   | 0.040816   | 0.040816   |   0.0 |  0.35
Output  | 8.2837e-05 | 8.2837e-05 | 8.2837e-05 |   0.0 |  0.00
Modify  | 0.14502    | 0.14502    | 0.14502    |   0.0 |  1.25
Other   |            | 0.0224     |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5444.00 ave        5444 max        5444 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277522.0 ave      277522 max      277522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277522
Ave neighs/atom = 138.76100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.639750567135, Press = 1.63313824770105
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -7864.5495   -7864.5495   -7944.2277   -7944.2277    308.36296    308.36296    23399.538    23399.538   -271.92713   -271.92713 
   47000     -7865.33     -7865.33   -7945.3826   -7945.3826    309.81187    309.81187     23409.77     23409.77   -1062.2195   -1062.2195 
Loop time of 11.5637 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.472 ns/day, 3.212 hours/ns, 86.478 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    | 11.355     | 11.355     | 11.355     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040822   | 0.040822   | 0.040822   |   0.0 |  0.35
Output  | 9.9666e-05 | 9.9666e-05 | 9.9666e-05 |   0.0 |  0.00
Modify  | 0.14469    | 0.14469    | 0.14469    |   0.0 |  1.25
Other   |            | 0.02261    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5456.00 ave        5456 max        5456 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277282.0 ave      277282 max      277282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277282
Ave neighs/atom = 138.64100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.611385086536, Press = 0.870718852659875
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000     -7865.33     -7865.33   -7945.3826   -7945.3826    309.81187    309.81187     23409.77     23409.77   -1062.2195   -1062.2195 
   48000   -7864.9698   -7864.9698   -7945.9224   -7945.9224    313.29489    313.29489    23406.081    23406.081   -1075.7826   -1075.7826 
Loop time of 11.5009 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.512 ns/day, 3.195 hours/ns, 86.950 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.296     | 11.296     | 11.296     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040344   | 0.040344   | 0.040344   |   0.0 |  0.35
Output  | 9.5186e-05 | 9.5186e-05 | 9.5186e-05 |   0.0 |  0.00
Modify  | 0.14206    | 0.14206    | 0.14206    |   0.0 |  1.24
Other   |            | 0.02206    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5441.00 ave        5441 max        5441 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277302.0 ave      277302 max      277302 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277302
Ave neighs/atom = 138.65100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.620466169694, Press = 2.4450477051435
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -7864.9698   -7864.9698   -7945.9224   -7945.9224    313.29489    313.29489    23406.081    23406.081   -1075.7826   -1075.7826 
   49000   -7859.8012   -7859.8012   -7941.5724   -7941.5724    316.46296    316.46296     23335.38     23335.38     4660.672     4660.672 
Loop time of 11.5603 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.474 ns/day, 3.211 hours/ns, 86.503 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.353     | 11.353     | 11.353     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04096    | 0.04096    | 0.04096    |   0.0 |  0.35
Output  | 8.2382e-05 | 8.2382e-05 | 8.2382e-05 |   0.0 |  0.00
Modify  | 0.14409    | 0.14409    | 0.14409    |   0.0 |  1.25
Other   |            | 0.02259    |            |       |  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:      277306.0 ave      277306 max      277306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277306
Ave neighs/atom = 138.65300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.641669038318, Press = 2.24860841362106
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -7859.8012   -7859.8012   -7941.5724   -7941.5724    316.46296    316.46296     23335.38     23335.38     4660.672     4660.672 
   50000   -7865.4808   -7865.4808   -7946.2992   -7946.2992    312.77532    312.77532    23394.195    23394.195   -263.83143   -263.83143 
Loop time of 11.7322 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.364 ns/day, 3.259 hours/ns, 85.235 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.518     | 11.518     | 11.518     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042138   | 0.042138   | 0.042138   |   0.0 |  0.36
Output  | 5.4983e-05 | 5.4983e-05 | 5.4983e-05 |   0.0 |  0.00
Modify  | 0.14849    | 0.14849    | 0.14849    |   0.0 |  1.27
Other   |            | 0.0236     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5461.00 ave        5461 max        5461 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      278228.0 ave      278228 max      278228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278228
Ave neighs/atom = 139.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 = 313.678917961622, Press = -0.339930136440479
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -7865.4808   -7865.4808   -7946.2992   -7946.2992    312.77532    312.77532    23394.195    23394.195   -263.83143   -263.83143 
   51000   -7863.9295   -7863.9295   -7946.1643   -7946.1643    318.25732    318.25732    23406.528    23406.528   -605.24344   -605.24344 
Loop time of 11.5721 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.466 ns/day, 3.214 hours/ns, 86.415 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.365     | 11.365     | 11.365     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040682   | 0.040682   | 0.040682   |   0.0 |  0.35
Output  | 8.6317e-05 | 8.6317e-05 | 8.6317e-05 |   0.0 |  0.00
Modify  | 0.14408    | 0.14408    | 0.14408    |   0.0 |  1.25
Other   |            | 0.02235    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5448.00 ave        5448 max        5448 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277394.0 ave      277394 max      277394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277394
Ave neighs/atom = 138.69700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.674518560139, Press = 0.866345663163888
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -7863.9295   -7863.9295   -7946.1643   -7946.1643    318.25732    318.25732    23406.528    23406.528   -605.24344   -605.24344 
   52000   -7865.1517   -7865.1517   -7945.5015   -7945.5015    310.96234    310.96234    23393.741    23393.741   -34.485175   -34.485175 
Loop time of 11.529 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.494 ns/day, 3.202 hours/ns, 86.738 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.323     | 11.323     | 11.323     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040415   | 0.040415   | 0.040415   |   0.0 |  0.35
Output  | 5.7811e-05 | 5.7811e-05 | 5.7811e-05 |   0.0 |  0.00
Modify  | 0.14319    | 0.14319    | 0.14319    |   0.0 |  1.24
Other   |            | 0.0225     |            |       |  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:      277316.0 ave      277316 max      277316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277316
Ave neighs/atom = 138.65800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.655143501172, Press = 1.95395243554218
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -7865.1517   -7865.1517   -7945.5015   -7945.5015    310.96234    310.96234    23393.741    23393.741   -34.485175   -34.485175 
   53000   -7863.3821   -7863.3821   -7944.9635   -7944.9635    315.72832    315.72832    23376.643    23376.643    1437.9731    1437.9731 
Loop time of 11.5008 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.513 ns/day, 3.195 hours/ns, 86.950 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.295     | 11.295     | 11.295     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040512   | 0.040512   | 0.040512   |   0.0 |  0.35
Output  | 8.7547e-05 | 8.7547e-05 | 8.7547e-05 |   0.0 |  0.00
Modify  | 0.14256    | 0.14256    | 0.14256    |   0.0 |  1.24
Other   |            | 0.02227    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5452.00 ave        5452 max        5452 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277460.0 ave      277460 max      277460 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277460
Ave neighs/atom = 138.73000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.656522185672, Press = 0.948690268571658
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -7863.3821   -7863.3821   -7944.9635   -7944.9635    315.72832    315.72832    23376.643    23376.643    1437.9731    1437.9731 
   54000   -7862.8861   -7862.8861   -7943.9329   -7943.9329    313.65952    313.65952    23394.589    23394.589    300.45904    300.45904 
Loop time of 11.6422 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.421 ns/day, 3.234 hours/ns, 85.895 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.431     | 11.431     | 11.431     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041346   | 0.041346   | 0.041346   |   0.0 |  0.36
Output  | 8.4111e-05 | 8.4111e-05 | 8.4111e-05 |   0.0 |  0.00
Modify  | 0.14684    | 0.14684    | 0.14684    |   0.0 |  1.26
Other   |            | 0.02307    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5438.00 ave        5438 max        5438 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277546.0 ave      277546 max      277546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277546
Ave neighs/atom = 138.77300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.723209972446, Press = -0.803406381546628
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -7862.8861   -7862.8861   -7943.9329   -7943.9329    313.65952    313.65952    23394.589    23394.589    300.45904    300.45904 
   55000   -7863.6058   -7863.6058    -7945.466    -7945.466    316.80717    316.80717     23438.47     23438.47   -3095.2155   -3095.2155 
Loop time of 11.5768 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.463 ns/day, 3.216 hours/ns, 86.380 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.369     | 11.369     | 11.369     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040917   | 0.040917   | 0.040917   |   0.0 |  0.35
Output  | 8.3789e-05 | 8.3789e-05 | 8.3789e-05 |   0.0 |  0.00
Modify  | 0.14459    | 0.14459    | 0.14459    |   0.0 |  1.25
Other   |            | 0.02253    |            |       |  0.19

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:      277648.0 ave      277648 max      277648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277648
Ave neighs/atom = 138.82400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.687614273732, Press = 1.10700459805318
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -7863.6058   -7863.6058    -7945.466    -7945.466    316.80717    316.80717     23438.47     23438.47   -3095.2155   -3095.2155 
   56000   -7867.0491   -7867.0491   -7948.3131   -7948.3131    314.49999    314.49999     23377.61     23377.61    1075.5385    1075.5385 
Loop time of 11.5161 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.503 ns/day, 3.199 hours/ns, 86.835 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.31      | 11.31      | 11.31      |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040573   | 0.040573   | 0.040573   |   0.0 |  0.35
Output  | 8.6077e-05 | 8.6077e-05 | 8.6077e-05 |   0.0 |  0.00
Modify  | 0.14315    | 0.14315    | 0.14315    |   0.0 |  1.24
Other   |            | 0.02248    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5438.00 ave        5438 max        5438 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      276838.0 ave      276838 max      276838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 276838
Ave neighs/atom = 138.41900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.639599152827, Press = 1.94345421200483
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -7867.0491   -7867.0491   -7948.3131   -7948.3131    314.49999    314.49999     23377.61     23377.61    1075.5385    1075.5385 
   57000   -7864.7399   -7864.7399   -7942.8616   -7942.8616    302.33919    302.33919    23388.757    23388.757    352.68261    352.68261 
Loop time of 11.7119 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.377 ns/day, 3.253 hours/ns, 85.384 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.498     | 11.498     | 11.498     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041652   | 0.041652   | 0.041652   |   0.0 |  0.36
Output  | 8.4267e-05 | 8.4267e-05 | 8.4267e-05 |   0.0 |  0.00
Modify  | 0.14898    | 0.14898    | 0.14898    |   0.0 |  1.27
Other   |            | 0.02351    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5438.00 ave        5438 max        5438 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277296.0 ave      277296 max      277296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277296
Ave neighs/atom = 138.64800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.575016839484, Press = 0.234867716447031
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -7864.7399   -7864.7399   -7942.8616   -7942.8616    302.33919    302.33919    23388.757    23388.757    352.68261    352.68261 
   58000   -7868.0101   -7868.0101    -7947.231    -7947.231    306.59314    306.59314    23409.131    23409.131   -1118.7612   -1118.7612 
Loop time of 11.7051 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.381 ns/day, 3.251 hours/ns, 85.433 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.493     | 11.493     | 11.493     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041607   | 0.041607   | 0.041607   |   0.0 |  0.36
Output  | 6.5378e-05 | 6.5378e-05 | 6.5378e-05 |   0.0 |  0.00
Modify  | 0.14683    | 0.14683    | 0.14683    |   0.0 |  1.25
Other   |            | 0.02331    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5452.00 ave        5452 max        5452 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277604.0 ave      277604 max      277604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277604
Ave neighs/atom = 138.80200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.555961399112, Press = 0.860679558844028
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -7868.0101   -7868.0101    -7947.231    -7947.231    306.59314    306.59314    23409.131    23409.131   -1118.7612   -1118.7612 
   59000   -7863.8724   -7863.8724   -7945.0037   -7945.0037    313.98654    313.98654    23388.432    23388.432    453.64511    453.64511 
Loop time of 11.6301 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.429 ns/day, 3.231 hours/ns, 85.984 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.419     | 11.419     | 11.419     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041221   | 0.041221   | 0.041221   |   0.0 |  0.35
Output  | 8.2117e-05 | 8.2117e-05 | 8.2117e-05 |   0.0 |  0.00
Modify  | 0.14662    | 0.14662    | 0.14662    |   0.0 |  1.26
Other   |            | 0.02319    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5451.00 ave        5451 max        5451 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277210.0 ave      277210 max      277210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277210
Ave neighs/atom = 138.60500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.504583006002, Press = 1.61018501517401
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -7863.8724   -7863.8724   -7945.0037   -7945.0037    313.98654    313.98654    23388.432    23388.432    453.64511    453.64511 
   60000   -7865.4682   -7865.4682   -7946.0175   -7946.0175     311.7342     311.7342     23356.68     23356.68    2495.4905    2495.4905 
Loop time of 11.5428 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.485 ns/day, 3.206 hours/ns, 86.634 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.336     | 11.336     | 11.336     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040441   | 0.040441   | 0.040441   |   0.0 |  0.35
Output  | 0.0001003  | 0.0001003  | 0.0001003  |   0.0 |  0.00
Modify  | 0.1439     | 0.1439     | 0.1439     |   0.0 |  1.25
Other   |            | 0.02236    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5451.00 ave        5451 max        5451 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277532.0 ave      277532 max      277532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277532
Ave neighs/atom = 138.76600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.468627694717, Press = 0.351683838327094
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -7865.4682   -7865.4682   -7946.0175   -7946.0175     311.7342     311.7342     23356.68     23356.68    2495.4905    2495.4905 
   61000   -7861.8217   -7861.8217   -7943.2822   -7943.2822    315.26033    315.26033    23441.992    23441.992   -3047.5274   -3047.5274 
Loop time of 11.5614 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.473 ns/day, 3.212 hours/ns, 86.495 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.356     | 11.356     | 11.356     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040625   | 0.040625   | 0.040625   |   0.0 |  0.35
Output  | 0.00021949 | 0.00021949 | 0.00021949 |   0.0 |  0.00
Modify  | 0.14303    | 0.14303    | 0.14303    |   0.0 |  1.24
Other   |            | 0.02185    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5444.00 ave        5444 max        5444 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277874.0 ave      277874 max      277874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277874
Ave neighs/atom = 138.93700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.450777380254, Press = -0.478241049403628
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.195 | 4.195 | 4.195 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -7861.8217   -7861.8217   -7943.2822   -7943.2822    315.26033    315.26033    23441.992    23441.992   -3047.5274   -3047.5274 
   62000   -7865.4802   -7865.4802   -7946.9043   -7946.9043    315.11972    315.11972    23423.831    23423.831   -2199.6041   -2199.6041 
Loop time of 11.6417 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.422 ns/day, 3.234 hours/ns, 85.898 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.43      | 11.43      | 11.43      |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041128   | 0.041128   | 0.041128   |   0.0 |  0.35
Output  | 9.2067e-05 | 9.2067e-05 | 9.2067e-05 |   0.0 |  0.00
Modify  | 0.14766    | 0.14766    | 0.14766    |   0.0 |  1.27
Other   |            | 0.02312    |            |       |  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:      277284.0 ave      277284 max      277284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277284
Ave neighs/atom = 138.64200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.456395572932, Press = 1.76093848548637
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -7865.4802   -7865.4802   -7946.9043   -7946.9043    315.11972    315.11972    23423.831    23423.831   -2199.6041   -2199.6041 
   63000   -7868.1697   -7868.1697   -7948.8039   -7948.8039    312.06264    312.06264    23368.549    23368.549    1908.1955    1908.1955 
Loop time of 11.6176 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.437 ns/day, 3.227 hours/ns, 86.076 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.409     | 11.409     | 11.409     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040931   | 0.040931   | 0.040931   |   0.0 |  0.35
Output  | 8.3601e-05 | 8.3601e-05 | 8.3601e-05 |   0.0 |  0.00
Modify  | 0.14491    | 0.14491    | 0.14491    |   0.0 |  1.25
Other   |            | 0.02232    |            |       |  0.19

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:      277058.0 ave      277058 max      277058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277058
Ave neighs/atom = 138.52900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.382264743167, Press = 1.76633060660368
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -7868.1697   -7868.1697   -7948.8039   -7948.8039    312.06264    312.06264    23368.549    23368.549    1908.1955    1908.1955 
   64000   -7865.3228   -7865.3228   -7943.6154   -7943.6154    303.00066    303.00066    23373.576    23373.576    1525.5787    1525.5787 
Loop time of 11.5111 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.506 ns/day, 3.198 hours/ns, 86.873 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.306     | 11.306     | 11.306     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04033    | 0.04033    | 0.04033    |   0.0 |  0.35
Output  | 8.3673e-05 | 8.3673e-05 | 8.3673e-05 |   0.0 |  0.00
Modify  | 0.14284    | 0.14284    | 0.14284    |   0.0 |  1.24
Other   |            | 0.02223    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5443.00 ave        5443 max        5443 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277396.0 ave      277396 max      277396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277396
Ave neighs/atom = 138.69800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.369740036064, Press = 0.584358194166252
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -7865.3228   -7865.3228   -7943.6154   -7943.6154    303.00066    303.00066    23373.576    23373.576    1525.5787    1525.5787 
   65000   -7864.6193   -7864.6193    -7945.628    -7945.628    313.51193    313.51193     23410.18     23410.18   -827.96526   -827.96526 
Loop time of 11.5535 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.478 ns/day, 3.209 hours/ns, 86.554 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.345     | 11.345     | 11.345     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04071    | 0.04071    | 0.04071    |   0.0 |  0.35
Output  | 5.5289e-05 | 5.5289e-05 | 5.5289e-05 |   0.0 |  0.00
Modify  | 0.14488    | 0.14488    | 0.14488    |   0.0 |  1.25
Other   |            | 0.02272    |            |       |  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:      277890.0 ave      277890 max      277890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277890
Ave neighs/atom = 138.94500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.34830552805, Press = 0.556267344802126
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -7864.6193   -7864.6193    -7945.628    -7945.628    313.51193    313.51193     23410.18     23410.18   -827.96526   -827.96526 
   66000   -7862.9201   -7862.9201    -7945.116    -7945.116    318.10661    318.10661    23406.707    23406.707   -705.07869   -705.07869 
Loop time of 11.6234 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.433 ns/day, 3.229 hours/ns, 86.033 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.413     | 11.413     | 11.413     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041219   | 0.041219   | 0.041219   |   0.0 |  0.35
Output  | 5.752e-05  | 5.752e-05  | 5.752e-05  |   0.0 |  0.00
Modify  | 0.14614    | 0.14614    | 0.14614    |   0.0 |  1.26
Other   |            | 0.02291    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5453.00 ave        5453 max        5453 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277196.0 ave      277196 max      277196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277196
Ave neighs/atom = 138.59800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.377229018176, Press = 2.00341109721093
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -7862.9201   -7862.9201    -7945.116    -7945.116    318.10661    318.10661    23406.707    23406.707   -705.07869   -705.07869 
   67000   -7865.3636   -7865.3636   -7944.7929   -7944.7929    307.39941    307.39941    23340.578    23340.578    3902.0035    3902.0035 
Loop time of 11.5172 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.502 ns/day, 3.199 hours/ns, 86.826 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.313     | 11.313     | 11.313     |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040446   | 0.040446   | 0.040446   |   0.0 |  0.35
Output  | 0.00021649 | 0.00021649 | 0.00021649 |   0.0 |  0.00
Modify  | 0.14194    | 0.14194    | 0.14194    |   0.0 |  1.23
Other   |            | 0.02189    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5455.00 ave        5455 max        5455 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277250.0 ave      277250 max      277250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277250
Ave neighs/atom = 138.62500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.397759113628, Press = 1.0576867062998
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -7865.3636   -7865.3636   -7944.7929   -7944.7929    307.39941    307.39941    23340.578    23340.578    3902.0035    3902.0035 
   68000   -7863.8812   -7863.8812   -7943.9374   -7943.9374    309.82598    309.82598    23386.814    23386.814    553.71817    553.71817 
Loop time of 11.6229 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.434 ns/day, 3.229 hours/ns, 86.037 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.414     | 11.414     | 11.414     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041045   | 0.041045   | 0.041045   |   0.0 |  0.35
Output  | 5.4728e-05 | 5.4728e-05 | 5.4728e-05 |   0.0 |  0.00
Modify  | 0.14498    | 0.14498    | 0.14498    |   0.0 |  1.25
Other   |            | 0.02283    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5453.00 ave        5453 max        5453 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277906.0 ave      277906 max      277906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277906
Ave neighs/atom = 138.95300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.424336581336, Press = -0.484221516908002
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -7863.8812   -7863.8812   -7943.9374   -7943.9374    309.82598    309.82598    23386.814    23386.814    553.71817    553.71817 
   69000   -7864.5624   -7864.5624   -7944.8748   -7944.8748    310.81766    310.81766    23414.908    23414.908   -997.94892   -997.94892 
Loop time of 11.7153 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.375 ns/day, 3.254 hours/ns, 85.358 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.502     | 11.502     | 11.502     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041401   | 0.041401   | 0.041401   |   0.0 |  0.35
Output  | 8.4758e-05 | 8.4758e-05 | 8.4758e-05 |   0.0 |  0.00
Modify  | 0.14823    | 0.14823    | 0.14823    |   0.0 |  1.27
Other   |            | 0.02335    |            |       |  0.20

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:      277726.0 ave      277726 max      277726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277726
Ave neighs/atom = 138.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 = 313.424858763677, Press = 0.763246532978384
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -7864.5624   -7864.5624   -7944.8748   -7944.8748    310.81766    310.81766    23414.908    23414.908   -997.94892   -997.94892 
   70000   -7868.0748   -7868.0748   -7948.6887   -7948.6887    311.98418    311.98418    23388.958    23388.958    152.98523    152.98523 
Loop time of 11.8661 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.281 ns/day, 3.296 hours/ns, 84.274 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.648     | 11.648     | 11.648     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042273   | 0.042273   | 0.042273   |   0.0 |  0.36
Output  | 8.4345e-05 | 8.4345e-05 | 8.4345e-05 |   0.0 |  0.00
Modify  | 0.15177    | 0.15177    | 0.15177    |   0.0 |  1.28
Other   |            | 0.02353    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5434.00 ave        5434 max        5434 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277240.0 ave      277240 max      277240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277240
Ave neighs/atom = 138.62000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.396621502191, Press = 1.57820411481938
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -7868.0748   -7868.0748   -7948.6887   -7948.6887    311.98418    311.98418    23388.958    23388.958    152.98523    152.98523 
   71000   -7863.6702   -7863.6702   -7945.2931   -7945.2931    315.88942    315.88942     23355.33     23355.33    2783.9376    2783.9376 
Loop time of 11.5533 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.478 ns/day, 3.209 hours/ns, 86.555 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.346     | 11.346     | 11.346     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040779   | 0.040779   | 0.040779   |   0.0 |  0.35
Output  | 0.00010264 | 0.00010264 | 0.00010264 |   0.0 |  0.00
Modify  | 0.14373    | 0.14373    | 0.14373    |   0.0 |  1.24
Other   |            | 0.02284    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5435.00 ave        5435 max        5435 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277228.0 ave      277228 max      277228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277228
Ave neighs/atom = 138.61400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.362665985766, Press = 0.456035862104066
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -7863.6702   -7863.6702   -7945.2931   -7945.2931    315.88942    315.88942     23355.33     23355.33    2783.9376    2783.9376 
   72000   -7868.1544   -7868.1544   -7945.1548   -7945.1548     297.9998     297.9998    23423.691    23423.691   -2009.0874   -2009.0874 
Loop time of 11.568 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.469 ns/day, 3.213 hours/ns, 86.445 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.36      | 11.36      | 11.36      |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040623   | 0.040623   | 0.040623   |   0.0 |  0.35
Output  | 0.00019111 | 0.00019111 | 0.00019111 |   0.0 |  0.00
Modify  | 0.14399    | 0.14399    | 0.14399    |   0.0 |  1.24
Other   |            | 0.02297    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5439.00 ave        5439 max        5439 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277968.0 ave      277968 max      277968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277968
Ave neighs/atom = 138.98400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.32255252494, Press = -1.12575150861645
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -7868.1544   -7868.1544   -7945.1548   -7945.1548     297.9998     297.9998    23423.691    23423.691   -2009.0874   -2009.0874 
   73000   -7862.3559   -7862.3559    -7943.865    -7943.865     315.4487     315.4487    23414.901    23414.901   -1448.2873   -1448.2873 
Loop time of 11.6763 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.400 ns/day, 3.243 hours/ns, 85.644 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.464     | 11.464     | 11.464     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041536   | 0.041536   | 0.041536   |   0.0 |  0.36
Output  | 0.00010931 | 0.00010931 | 0.00010931 |   0.0 |  0.00
Modify  | 0.1474     | 0.1474     | 0.1474     |   0.0 |  1.26
Other   |            | 0.02326    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5444.00 ave        5444 max        5444 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277114.0 ave      277114 max      277114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277114
Ave neighs/atom = 138.55700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.306555525428, Press = 1.28567408675874
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -7862.3559   -7862.3559    -7943.865    -7943.865     315.4487     315.4487    23414.901    23414.901   -1448.2873   -1448.2873 
   74000   -7866.6028   -7866.6028   -7947.6995   -7947.6995    313.85233    313.85233    23387.158    23387.158    191.30544    191.30544 
Loop time of 11.6177 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.437 ns/day, 3.227 hours/ns, 86.075 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.408     | 11.408     | 11.408     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041106   | 0.041106   | 0.041106   |   0.0 |  0.35
Output  | 6.5416e-05 | 6.5416e-05 | 6.5416e-05 |   0.0 |  0.00
Modify  | 0.14576    | 0.14576    | 0.14576    |   0.0 |  1.25
Other   |            | 0.02257    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5437.00 ave        5437 max        5437 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277420.0 ave      277420 max      277420 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277420
Ave neighs/atom = 138.71000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.309623172832, Press = 1.16635312222017
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -7866.6028   -7866.6028   -7947.6995   -7947.6995    313.85233    313.85233    23387.158    23387.158    191.30544    191.30544 
   75000   -7863.5141   -7863.5141    -7944.679    -7944.679    314.11659    314.11659    23383.555    23383.555     852.3965     852.3965 
Loop time of 11.7797 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.335 ns/day, 3.272 hours/ns, 84.892 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.568     | 11.568     | 11.568     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041718   | 0.041718   | 0.041718   |   0.0 |  0.35
Output  | 6.4953e-05 | 6.4953e-05 | 6.4953e-05 |   0.0 |  0.00
Modify  | 0.1471     | 0.1471     | 0.1471     |   0.0 |  1.25
Other   |            | 0.02327    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5451.00 ave        5451 max        5451 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277050.0 ave      277050 max      277050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277050
Ave neighs/atom = 138.52500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.284718171952, Press = 0.593935669458674
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -7863.5141   -7863.5141    -7944.679    -7944.679    314.11659    314.11659    23383.555    23383.555     852.3965     852.3965 
   76000   -7868.2161   -7868.2161   -7946.6102   -7946.6102     303.3935     303.3935    23405.349    23405.349   -1085.1374   -1085.1374 
Loop time of 11.6527 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.415 ns/day, 3.237 hours/ns, 85.817 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.442     | 11.442     | 11.442     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041021   | 0.041021   | 0.041021   |   0.0 |  0.35
Output  | 0.0001041  | 0.0001041  | 0.0001041  |   0.0 |  0.00
Modify  | 0.14648    | 0.14648    | 0.14648    |   0.0 |  1.26
Other   |            | 0.02269    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5460.00 ave        5460 max        5460 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277582.0 ave      277582 max      277582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277582
Ave neighs/atom = 138.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 = 313.246663771309, Press = 0.442539700085067
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -7868.2161   -7868.2161   -7946.6102   -7946.6102     303.3935     303.3935    23405.349    23405.349   -1085.1374   -1085.1374 
   77000    -7864.647    -7864.647   -7944.5148   -7944.5148     309.0968     309.0968     23415.96     23415.96   -1426.8339   -1426.8339 
Loop time of 11.7585 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.348 ns/day, 3.266 hours/ns, 85.045 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.543     | 11.543     | 11.543     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042159   | 0.042159   | 0.042159   |   0.0 |  0.36
Output  | 8.5174e-05 | 8.5174e-05 | 8.5174e-05 |   0.0 |  0.00
Modify  | 0.14979    | 0.14979    | 0.14979    |   0.0 |  1.27
Other   |            | 0.02353    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5456.00 ave        5456 max        5456 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277390.0 ave      277390 max      277390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277390
Ave neighs/atom = 138.69500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.225645116934, Press = 1.23528231639236
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000    -7864.647    -7864.647   -7944.5148   -7944.5148     309.0968     309.0968     23415.96     23415.96   -1426.8339   -1426.8339 
   78000   -7866.8466   -7866.8466   -7947.5432   -7947.5432     312.3042     312.3042    23350.074    23350.074    2824.5392    2824.5392 
Loop time of 11.5344 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.491 ns/day, 3.204 hours/ns, 86.697 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.328     | 11.328     | 11.328     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040553   | 0.040553   | 0.040553   |   0.0 |  0.35
Output  | 0.00015357 | 0.00015357 | 0.00015357 |   0.0 |  0.00
Modify  | 0.14368    | 0.14368    | 0.14368    |   0.0 |  1.25
Other   |            | 0.02234    |            |       |  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:      277324.0 ave      277324 max      277324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277324
Ave neighs/atom = 138.66200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.177700596337, Press = 1.09721030372829
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -7866.8466   -7866.8466   -7947.5432   -7947.5432     312.3042     312.3042    23350.074    23350.074    2824.5392    2824.5392 
   79000   -7863.8417   -7863.8417   -7944.3964   -7944.3964    311.75503    311.75503    23394.565    23394.565    113.81854    113.81854 
Loop time of 11.6634 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.408 ns/day, 3.240 hours/ns, 85.739 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.45      | 11.45      | 11.45      |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041147   | 0.041147   | 0.041147   |   0.0 |  0.35
Output  | 9.1565e-05 | 9.1565e-05 | 9.1565e-05 |   0.0 |  0.00
Modify  | 0.14613    | 0.14613    | 0.14613    |   0.0 |  1.25
Other   |            | 0.02608    |            |       |  0.22

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5444.00 ave        5444 max        5444 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277758.0 ave      277758 max      277758 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277758
Ave neighs/atom = 138.87900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.167301515474, Press = -0.312686285935902
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -7863.8417   -7863.8417   -7944.3964   -7944.3964    311.75503    311.75503    23394.565    23394.565    113.81854    113.81854 
   80000    -7865.497    -7865.497   -7944.3118   -7944.3118     305.0215     305.0215    23427.493    23427.493   -2235.9649   -2235.9649 
Loop time of 11.5163 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.502 ns/day, 3.199 hours/ns, 86.833 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.312     | 11.312     | 11.312     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04059    | 0.04059    | 0.04059    |   0.0 |  0.35
Output  | 8.2982e-05 | 8.2982e-05 | 8.2982e-05 |   0.0 |  0.00
Modify  | 0.14164    | 0.14164    | 0.14164    |   0.0 |  1.23
Other   |            | 0.02172    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5446.00 ave        5446 max        5446 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277596.0 ave      277596 max      277596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277596
Ave neighs/atom = 138.79800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.15271518465, Press = 0.884321913449315
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000    -7865.497    -7865.497   -7944.3118   -7944.3118     305.0215     305.0215    23427.493    23427.493   -2235.9649   -2235.9649 
   81000   -7862.9599   -7862.9599   -7944.0232   -7944.0232    313.72321    313.72321    23375.747    23375.747    1328.3666    1328.3666 
Loop time of 11.7198 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.372 ns/day, 3.256 hours/ns, 85.325 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.506     | 11.506     | 11.506     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041759   | 0.041759   | 0.041759   |   0.0 |  0.36
Output  | 8.533e-05  | 8.533e-05  | 8.533e-05  |   0.0 |  0.00
Modify  | 0.14836    | 0.14836    | 0.14836    |   0.0 |  1.27
Other   |            | 0.02328    |            |       |  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:      277128.0 ave      277128 max      277128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277128
Ave neighs/atom = 138.56400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.152677757798, Press = 1.32215938409068
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -7862.9599   -7862.9599   -7944.0232   -7944.0232    313.72321    313.72321    23375.747    23375.747    1328.3666    1328.3666 
   82000   -7863.6533   -7863.6533   -7945.4879   -7945.4879    316.70851    316.70851     23383.01     23383.01    366.64677    366.64677 
Loop time of 11.6873 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.393 ns/day, 3.246 hours/ns, 85.563 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.476     | 11.476     | 11.476     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041086   | 0.041086   | 0.041086   |   0.0 |  0.35
Output  | 0.000235   | 0.000235   | 0.000235   |   0.0 |  0.00
Modify  | 0.14687    | 0.14687    | 0.14687    |   0.0 |  1.26
Other   |            | 0.02301    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5428.00 ave        5428 max        5428 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277952.0 ave      277952 max      277952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277952
Ave neighs/atom = 138.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 = 313.160968119562, Press = 0.399460499637219
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000   -7863.6533   -7863.6533   -7945.4879   -7945.4879    316.70851    316.70851     23383.01     23383.01    366.64677    366.64677 
   83000   -7862.7173   -7862.7173   -7943.0245   -7943.0245    310.79742    310.79742    23407.476    23407.476   -900.65575   -900.65575 
Loop time of 11.5537 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.478 ns/day, 3.209 hours/ns, 86.552 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.346     | 11.346     | 11.346     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040892   | 0.040892   | 0.040892   |   0.0 |  0.35
Output  | 8.3692e-05 | 8.3692e-05 | 8.3692e-05 |   0.0 |  0.00
Modify  | 0.14452    | 0.14452    | 0.14452    |   0.0 |  1.25
Other   |            | 0.02237    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5451.00 ave        5451 max        5451 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277548.0 ave      277548 max      277548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277548
Ave neighs/atom = 138.77400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.184807928614, Press = 0.773159423808453
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -7862.7173   -7862.7173   -7943.0245   -7943.0245    310.79742    310.79742    23407.476    23407.476   -900.65575   -900.65575 
   84000   -7866.0147   -7866.0147    -7946.232    -7946.232    310.44947    310.44947    23394.129    23394.129   -91.738258   -91.738258 
Loop time of 11.4998 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.513 ns/day, 3.194 hours/ns, 86.958 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.294     | 11.294     | 11.294     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040359   | 0.040359   | 0.040359   |   0.0 |  0.35
Output  | 0.00019507 | 0.00019507 | 0.00019507 |   0.0 |  0.00
Modify  | 0.14284    | 0.14284    | 0.14284    |   0.0 |  1.24
Other   |            | 0.02222    |            |       |  0.19

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:      277482.0 ave      277482 max      277482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277482
Ave neighs/atom = 138.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 = 313.212495327541, Press = 0.987848128682764
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -7866.0147   -7866.0147    -7946.232    -7946.232    310.44947    310.44947    23394.129    23394.129   -91.738258   -91.738258 
   85000   -7862.4953   -7862.4953    -7944.987    -7944.987    319.25159    319.25159    23355.898    23355.898    2776.5647    2776.5647 
Loop time of 11.7497 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.353 ns/day, 3.264 hours/ns, 85.109 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.536     | 11.536     | 11.536     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.041492   | 0.041492   | 0.041492   |   0.0 |  0.35
Output  | 0.00016093 | 0.00016093 | 0.00016093 |   0.0 |  0.00
Modify  | 0.14908    | 0.14908    | 0.14908    |   0.0 |  1.27
Other   |            | 0.02265    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5439.00 ave        5439 max        5439 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277262.0 ave      277262 max      277262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277262
Ave neighs/atom = 138.63100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.215493197725, Press = 0.405935686449942
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -7862.4953   -7862.4953    -7944.987    -7944.987    319.25159    319.25159    23355.898    23355.898    2776.5647    2776.5647 
   86000   -7865.8546   -7865.8546   -7945.9296   -7945.9296     309.8985     309.8985    23414.956    23414.956   -1658.2628   -1658.2628 
Loop time of 11.4781 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.527 ns/day, 3.188 hours/ns, 87.122 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.276     | 11.276     | 11.276     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039846   | 0.039846   | 0.039846   |   0.0 |  0.35
Output  | 0.00010864 | 0.00010864 | 0.00010864 |   0.0 |  0.00
Modify  | 0.14084    | 0.14084    | 0.14084    |   0.0 |  1.23
Other   |            | 0.02109    |            |       |  0.18

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5446.00 ave        5446 max        5446 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277962.0 ave      277962 max      277962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277962
Ave neighs/atom = 138.98100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.224796149039, Press = -0.318953166683244
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -7865.8546   -7865.8546   -7945.9296   -7945.9296     309.8985     309.8985    23414.956    23414.956   -1658.2628   -1658.2628 
   87000   -7862.1965   -7862.1965   -7944.5753   -7944.5753    318.81453    318.81453    23438.723    23438.723    -2554.874    -2554.874 
Loop time of 11.4557 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.542 ns/day, 3.182 hours/ns, 87.293 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.255     | 11.255     | 11.255     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040114   | 0.040114   | 0.040114   |   0.0 |  0.35
Output  | 9.0506e-05 | 9.0506e-05 | 9.0506e-05 |   0.0 |  0.00
Modify  | 0.13992    | 0.13992    | 0.13992    |   0.0 |  1.22
Other   |            | 0.02088    |            |       |  0.18

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:      277324.0 ave      277324 max      277324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277324
Ave neighs/atom = 138.66200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.218074759862, Press = 1.38584147813304
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -7862.1965   -7862.1965   -7944.5753   -7944.5753    318.81453    318.81453    23438.723    23438.723    -2554.874    -2554.874 
   88000   -7865.9755   -7865.9755   -7946.7162   -7946.7162    312.47495    312.47495    23375.259    23375.259    1386.1579    1386.1579 
Loop time of 11.4405 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.552 ns/day, 3.178 hours/ns, 87.408 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.24      | 11.24      | 11.24      |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039927   | 0.039927   | 0.039927   |   0.0 |  0.35
Output  | 8.7705e-05 | 8.7705e-05 | 8.7705e-05 |   0.0 |  0.00
Modify  | 0.13992    | 0.13992    | 0.13992    |   0.0 |  1.22
Other   |            | 0.02083    |            |       |  0.18

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5451.00 ave        5451 max        5451 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277060.0 ave      277060 max      277060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277060
Ave neighs/atom = 138.53000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.20599932107, Press = 1.1196273862896
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000   -7865.9755   -7865.9755   -7946.7162   -7946.7162    312.47495    312.47495    23375.259    23375.259    1386.1579    1386.1579 
   89000   -7865.2405   -7865.2405   -7945.7378   -7945.7378    311.53257    311.53257    23388.744    23388.744    276.83964    276.83964 
Loop time of 11.5614 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.473 ns/day, 3.212 hours/ns, 86.494 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.357     | 11.357     | 11.357     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040445   | 0.040445   | 0.040445   |   0.0 |  0.35
Output  | 8.439e-05  | 8.439e-05  | 8.439e-05  |   0.0 |  0.00
Modify  | 0.14259    | 0.14259    | 0.14259    |   0.0 |  1.23
Other   |            | 0.02125    |            |       |  0.18

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5458.00 ave        5458 max        5458 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277548.0 ave      277548 max      277548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277548
Ave neighs/atom = 138.77400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.195601908448, Press = 0.62313805395975
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -7865.2405   -7865.2405   -7945.7378   -7945.7378    311.53257    311.53257    23388.744    23388.744    276.83964    276.83964 
   90000   -7865.2313   -7865.2313   -7946.5927   -7946.5927    314.87707    314.87707    23413.512    23413.512   -1521.1989   -1521.1989 
Loop time of 11.83 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.303 ns/day, 3.286 hours/ns, 84.531 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.612     | 11.612     | 11.612     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.042234   | 0.042234   | 0.042234   |   0.0 |  0.36
Output  | 6.3875e-05 | 6.3875e-05 | 6.3875e-05 |   0.0 |  0.00
Modify  | 0.15167    | 0.15167    | 0.15167    |   0.0 |  1.28
Other   |            | 0.02367    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5465.00 ave        5465 max        5465 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277448.0 ave      277448 max      277448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277448
Ave neighs/atom = 138.72400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.15200645693, Press = 0.563433622769813
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -7865.2313   -7865.2313   -7946.5927   -7946.5927    314.87707    314.87707    23413.512    23413.512   -1521.1989   -1521.1989 
   91000   -7867.0992   -7867.0992   -7946.1273   -7946.1273    305.84679    305.84679    23394.239    23394.239   -252.78912   -252.78912 
Loop time of 11.656 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.413 ns/day, 3.238 hours/ns, 85.793 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.447     | 11.447     | 11.447     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04103    | 0.04103    | 0.04103    |   0.0 |  0.35
Output  | 8.7962e-05 | 8.7962e-05 | 8.7962e-05 |   0.0 |  0.00
Modify  | 0.14569    | 0.14569    | 0.14569    |   0.0 |  1.25
Other   |            | 0.02176    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5445.00 ave        5445 max        5445 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277116.0 ave      277116 max      277116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277116
Ave neighs/atom = 138.55800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.147828447049, Press = 1.34737954448153
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000   -7867.0992   -7867.0992   -7946.1273   -7946.1273    305.84679    305.84679    23394.239    23394.239   -252.78912   -252.78912 
   92000   -7864.3708   -7864.3708   -7945.4815   -7945.4815    313.90697    313.90697    23352.152    23352.152    2907.7288    2907.7288 
Loop time of 11.5229 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.498 ns/day, 3.201 hours/ns, 86.784 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.32      | 11.32      | 11.32      |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040247   | 0.040247   | 0.040247   |   0.0 |  0.35
Output  | 6.2275e-05 | 6.2275e-05 | 6.2275e-05 |   0.0 |  0.00
Modify  | 0.14171    | 0.14171    | 0.14171    |   0.0 |  1.23
Other   |            | 0.02106    |            |       |  0.18

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5452.00 ave        5452 max        5452 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277486.0 ave      277486 max      277486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277486
Ave neighs/atom = 138.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 = 313.149609803337, Press = 0.456631647662146
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000   -7864.3708   -7864.3708   -7945.4815   -7945.4815    313.90697    313.90697    23352.152    23352.152    2907.7288    2907.7288 
   93000   -7865.0717   -7865.0717   -7946.3718   -7946.3718    314.63985    314.63985    23413.906    23413.906   -1392.8896   -1392.8896 
Loop time of 11.4588 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.540 ns/day, 3.183 hours/ns, 87.269 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.258     | 11.258     | 11.258     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040098   | 0.040098   | 0.040098   |   0.0 |  0.35
Output  | 6.4771e-05 | 6.4771e-05 | 6.4771e-05 |   0.0 |  0.00
Modify  | 0.1401     | 0.1401     | 0.1401     |   0.0 |  1.22
Other   |            | 0.02083    |            |       |  0.18

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5454.00 ave        5454 max        5454 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277750.0 ave      277750 max      277750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277750
Ave neighs/atom = 138.87500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.144446205365, Press = -0.27294737178994
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000   -7865.0717   -7865.0717   -7946.3718   -7946.3718    314.63985    314.63985    23413.906    23413.906   -1392.8896   -1392.8896 
   94000    -7863.059    -7863.059    -7944.601    -7944.601     315.5757     315.5757    23428.747    23428.747    -2128.661    -2128.661 
Loop time of 11.6935 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.389 ns/day, 3.248 hours/ns, 85.517 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.484     | 11.484     | 11.484     |   0.0 | 98.21
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.040927   | 0.040927   | 0.040927   |   0.0 |  0.35
Output  | 6.468e-05  | 6.468e-05  | 6.468e-05  |   0.0 |  0.00
Modify  | 0.14661    | 0.14661    | 0.14661    |   0.0 |  1.25
Other   |            | 0.02161    |            |       |  0.18

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5444.00 ave        5444 max        5444 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277210.0 ave      277210 max      277210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277210
Ave neighs/atom = 138.60500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.150699349452, Press = 0.765818603018931
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000    -7863.059    -7863.059    -7944.601    -7944.601     315.5757     315.5757    23428.747    23428.747    -2128.661    -2128.661 
   95000   -7865.8147   -7865.8147   -7944.9268   -7944.9268    306.17185    306.17185    23383.988    23383.988    1072.5655    1072.5655 
Loop time of 11.4648 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.536 ns/day, 3.185 hours/ns, 87.224 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.264     | 11.264     | 11.264     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039853   | 0.039853   | 0.039853   |   0.0 |  0.35
Output  | 9.0919e-05 | 9.0919e-05 | 9.0919e-05 |   0.0 |  0.00
Modify  | 0.14007    | 0.14007    | 0.14007    |   0.0 |  1.22
Other   |            | 0.02096    |            |       |  0.18

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5453.00 ave        5453 max        5453 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277140.0 ave      277140 max      277140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277140
Ave neighs/atom = 138.57000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.147582368559, Press = 0.90748652273738
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000   -7865.8147   -7865.8147   -7944.9268   -7944.9268    306.17185    306.17185    23383.988    23383.988    1072.5655    1072.5655 
   96000   -7860.9985   -7860.9985   -7943.0338   -7943.0338    317.48496    317.48496    23386.595    23386.595    1105.1538    1105.1538 
Loop time of 11.4564 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.542 ns/day, 3.182 hours/ns, 87.287 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.255     | 11.255     | 11.255     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04003    | 0.04003    | 0.04003    |   0.0 |  0.35
Output  | 6.0196e-05 | 6.0196e-05 | 6.0196e-05 |   0.0 |  0.00
Modify  | 0.14023    | 0.14023    | 0.14023    |   0.0 |  1.22
Other   |            | 0.02101    |            |       |  0.18

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:      277570.0 ave      277570 max      277570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277570
Ave neighs/atom = 138.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 = 313.158291882768, Press = 0.388344132942744
next a
jump SELF top
variable a loop 2000
run 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.3
  ghost atom cutoff = 7.3
  binsize = 3.65, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.3
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000   -7860.9985   -7860.9985   -7943.0338   -7943.0338    317.48496    317.48496    23386.595    23386.595    1105.1538    1105.1538 
   97000   -7865.6658   -7865.6658    -7945.548    -7945.548    309.15239    309.15239    23409.529    23409.529   -833.86596   -833.86596 
Loop time of 11.4557 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.542 ns/day, 3.182 hours/ns, 87.293 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 11.255     | 11.255     | 11.255     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.039747   | 0.039747   | 0.039747   |   0.0 |  0.35
Output  | 6.0121e-05 | 6.0121e-05 | 6.0121e-05 |   0.0 |  0.00
Modify  | 0.14003    | 0.14003    | 0.14003    |   0.0 |  1.22
Other   |            | 0.02105    |            |       |  0.18

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:      277696.0 ave      277696 max      277696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0