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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 4.160539835691452*${_u_distance}
variable latticeconst_converted equal 4.160539835691452*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.16053983569145
Lattice spacing in x,y,z = 4.1605398 4.1605398 4.1605398
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 (41.605398 41.605398 41.605398)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (41.605398 41.605398 41.605398)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Ag

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

kim interactions Ag
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_PanBorovikovMendelev_2108_AgNi__MO_222110751402_000
pair_coeff * * Ag
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 107.8682

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 72019.3261787369 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_222110751402_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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0    -11723.68    -11723.68    -11885.55    -11885.55       313.15       313.15    72019.326    72019.326     2400.708     2400.708 
    1000   -11547.768   -11547.768   -11713.769   -11713.769    321.14117    321.14117     72773.83     72773.83   -959.00203   -959.00203 
Loop time of 78.2974 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.103 ns/day, 21.749 hours/ns, 12.772 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    | 77.182     | 77.182     | 77.182     |   0.0 | 98.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21872    | 0.21872    | 0.21872    |   0.0 |  0.28
Output  | 0.00032522 | 0.00032522 | 0.00032522 |   0.0 |  0.00
Modify  | 0.78849    | 0.78849    | 0.78849    |   0.0 |  1.01
Other   |            | 0.108      |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      560000.0 ave      560000 max      560000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 560000
Ave neighs/atom = 140.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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -11547.768   -11547.768   -11713.769   -11713.769    321.14117    321.14117     72773.83     72773.83   -959.00203   -959.00203 
    2000   -11566.221   -11566.221   -11724.191   -11724.191     305.6047     305.6047    72709.214    72709.214     -744.204     -744.204 
Loop time of 78.2742 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.104 ns/day, 21.743 hours/ns, 12.776 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    | 77.194     | 77.194     | 77.194     |   0.0 | 98.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21395    | 0.21395    | 0.21395    |   0.0 |  0.27
Output  | 0.00027267 | 0.00027267 | 0.00027267 |   0.0 |  0.00
Modify  | 0.76175    | 0.76175    | 0.76175    |   0.0 |  0.97
Other   |            | 0.1045     |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      579324.0 ave      579324 max      579324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 579324
Ave neighs/atom = 144.83100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -11566.221   -11566.221   -11724.191   -11724.191     305.6047     305.6047    72709.214    72709.214     -744.204     -744.204 
    3000   -11555.567   -11555.567   -11716.171   -11716.171    310.69851    310.69851    72643.011    72643.011    800.84894    800.84894 
Loop time of 79.4257 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.088 ns/day, 22.063 hours/ns, 12.590 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 78.329     | 78.329     | 78.329     |   0.0 | 98.62
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21587    | 0.21587    | 0.21587    |   0.0 |  0.27
Output  | 0.00024078 | 0.00024078 | 0.00024078 |   0.0 |  0.00
Modify  | 0.77552    | 0.77552    | 0.77552    |   0.0 |  0.98
Other   |            | 0.1052     |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8193.00 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578352.0 ave      578352 max      578352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578352
Ave neighs/atom = 144.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 = 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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -11555.567   -11555.567   -11716.171   -11716.171    310.69851    310.69851    72643.011    72643.011    800.84894    800.84894 
    4000   -11564.811   -11564.811   -11722.996   -11722.996    306.01881    306.01881     72608.44     72608.44    858.05643    858.05643 
Loop time of 73.5569 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.175 ns/day, 20.432 hours/ns, 13.595 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 72.592     | 72.592     | 72.592     |   0.0 | 98.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19833    | 0.19833    | 0.19833    |   0.0 |  0.27
Output  | 0.000221   | 0.000221   | 0.000221   |   0.0 |  0.00
Modify  | 0.668      | 0.668      | 0.668      |   0.0 |  0.91
Other   |            | 0.09849    |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      579340.0 ave      579340 max      579340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 579340
Ave neighs/atom = 144.83500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -11564.811   -11564.811   -11722.996   -11722.996    306.01881    306.01881     72608.44     72608.44    858.05643    858.05643 
    5000   -11558.897   -11558.897   -11723.254   -11723.254    317.95881    317.95881    72747.341    72747.341     -1061.76     -1061.76 
Loop time of 83.559 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.034 ns/day, 23.211 hours/ns, 11.968 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    | 82.427     | 82.427     | 82.427     |   0.0 | 98.65
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22191    | 0.22191    | 0.22191    |   0.0 |  0.27
Output  | 0.00017925 | 0.00017925 | 0.00017925 |   0.0 |  0.00
Modify  | 0.8035     | 0.8035     | 0.8035     |   0.0 |  0.96
Other   |            | 0.1065     |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578848.0 ave      578848 max      578848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578848
Ave neighs/atom = 144.71200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.525658662887, Press = 132.420958795181
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -11558.897   -11558.897   -11723.254   -11723.254    317.95881    317.95881    72747.341    72747.341     -1061.76     -1061.76 
    6000   -11555.978   -11555.978   -11716.902   -11716.902    311.31686    311.31686    72641.785    72641.785    770.77833    770.77833 
Loop time of 73.9635 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.168 ns/day, 20.545 hours/ns, 13.520 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    | 72.996     | 72.996     | 72.996     |   0.0 | 98.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19554    | 0.19554    | 0.19554    |   0.0 |  0.26
Output  | 0.00018342 | 0.00018342 | 0.00018342 |   0.0 |  0.00
Modify  | 0.67565    | 0.67565    | 0.67565    |   0.0 |  0.91
Other   |            | 0.09596    |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      577728.0 ave      577728 max      577728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 577728
Ave neighs/atom = 144.43200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.914577535824, Press = 35.0671023271316
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -11555.978   -11555.978   -11716.902   -11716.902    311.31686    311.31686    72641.785    72641.785    770.77833    770.77833 
    7000   -11563.284   -11563.284   -11723.142   -11723.142    309.25657    309.25657    72578.573    72578.573    1242.5633    1242.5633 
Loop time of 79.596 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.085 ns/day, 22.110 hours/ns, 12.563 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 78.591     | 78.591     | 78.591     |   0.0 | 98.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20203    | 0.20203    | 0.20203    |   0.0 |  0.25
Output  | 0.00022749 | 0.00022749 | 0.00022749 |   0.0 |  0.00
Modify  | 0.70581    | 0.70581    | 0.70581    |   0.0 |  0.89
Other   |            | 0.09707    |            |       |  0.12

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      579180.0 ave      579180 max      579180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 579180
Ave neighs/atom = 144.79500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.075488779252, Press = -0.913607465866256
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -11563.284   -11563.284   -11723.142   -11723.142    309.25657    309.25657    72578.573    72578.573    1242.5633    1242.5633 
    8000   -11553.125   -11553.125   -11718.588   -11718.588    320.10086    320.10086    72740.289    72740.289   -681.95451   -681.95451 
Loop time of 74.5792 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.159 ns/day, 20.716 hours/ns, 13.409 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 73.596     | 73.596     | 73.596     |   0.0 | 98.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19764    | 0.19764    | 0.19764    |   0.0 |  0.27
Output  | 0.00017739 | 0.00017739 | 0.00017739 |   0.0 |  0.00
Modify  | 0.6873     | 0.6873     | 0.6873     |   0.0 |  0.92
Other   |            | 0.0981     |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      579176.0 ave      579176 max      579176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 579176
Ave neighs/atom = 144.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.247794088045, Press = 1.08528109724446
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -11553.125   -11553.125   -11718.588   -11718.588    320.10086    320.10086    72740.289    72740.289   -681.95451   -681.95451 
    9000   -11559.945   -11559.945    -11722.28    -11722.28    314.04835    314.04835     72711.07     72711.07   -542.27057   -542.27057 
Loop time of 66.8975 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.292 ns/day, 18.583 hours/ns, 14.948 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    | 65.903     | 65.903     | 65.903     |   0.0 | 98.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19608    | 0.19608    | 0.19608    |   0.0 |  0.29
Output  | 0.00018034 | 0.00018034 | 0.00018034 |   0.0 |  0.00
Modify  | 0.69449    | 0.69449    | 0.69449    |   0.0 |  1.04
Other   |            | 0.1036     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578020.0 ave      578020 max      578020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578020
Ave neighs/atom = 144.50500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.546641558499, Press = 4.57375381390678
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -11559.945   -11559.945    -11722.28    -11722.28    314.04835    314.04835     72711.07     72711.07   -542.27057   -542.27057 
   10000   -11564.799   -11564.799   -11723.616   -11723.616    307.24295    307.24295    72592.062    72592.062    980.72665    980.72665 
Loop time of 81.8073 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.056 ns/day, 22.724 hours/ns, 12.224 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 80.616     | 80.616     | 80.616     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22685    | 0.22685    | 0.22685    |   0.0 |  0.28
Output  | 0.00018073 | 0.00018073 | 0.00018073 |   0.0 |  0.00
Modify  | 0.85213    | 0.85213    | 0.85213    |   0.0 |  1.04
Other   |            | 0.1124     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8193.00 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578160.0 ave      578160 max      578160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578160
Ave neighs/atom = 144.54000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.248199813559, Press = 3.10740678201154
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -11564.799   -11564.799   -11723.616   -11723.616    307.24295    307.24295    72592.062    72592.062    980.72665    980.72665 
   11000     -11559.3     -11559.3   -11721.079   -11721.079    312.97255    312.97255    72681.491    72681.491   -26.129024   -26.129024 
Loop time of 82.3979 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.049 ns/day, 22.888 hours/ns, 12.136 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    | 81.205     | 81.205     | 81.205     |   0.0 | 98.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22727    | 0.22727    | 0.22727    |   0.0 |  0.28
Output  | 0.00024121 | 0.00024121 | 0.00024121 |   0.0 |  0.00
Modify  | 0.85355    | 0.85355    | 0.85355    |   0.0 |  1.04
Other   |            | 0.1113     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      579274.0 ave      579274 max      579274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 579274
Ave neighs/atom = 144.81850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.195868859912, Press = -1.54556174789335
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000     -11559.3     -11559.3   -11721.079   -11721.079    312.97255    312.97255    72681.491    72681.491   -26.129024   -26.129024 
   12000   -11561.806   -11561.806     -11718.9     -11718.9    303.90878    303.90878     72725.11     72725.11   -625.46291   -625.46291 
Loop time of 73.1557 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.181 ns/day, 20.321 hours/ns, 13.669 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 72.078     | 72.078     | 72.078     |   0.0 | 98.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20749    | 0.20749    | 0.20749    |   0.0 |  0.28
Output  | 0.00018168 | 0.00018168 | 0.00018168 |   0.0 |  0.00
Modify  | 0.76313    | 0.76313    | 0.76313    |   0.0 |  1.04
Other   |            | 0.1068     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578420.0 ave      578420 max      578420 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578420
Ave neighs/atom = 144.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 = 312.939553686104, Press = 5.704793807687
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -11561.806   -11561.806     -11718.9     -11718.9    303.90878    303.90878     72725.11     72725.11   -625.46291   -625.46291 
   13000   -11556.961   -11556.961   -11717.758   -11717.758    311.07207    311.07207    72579.341    72579.341    1619.5697    1619.5697 
Loop time of 70.0982 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.233 ns/day, 19.472 hours/ns, 14.266 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 69.074     | 69.074     | 69.074     |   0.0 | 98.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19992    | 0.19992    | 0.19992    |   0.0 |  0.29
Output  | 0.00023178 | 0.00023178 | 0.00023178 |   0.0 |  0.00
Modify  | 0.71967    | 0.71967    | 0.71967    |   0.0 |  1.03
Other   |            | 0.1041     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578518.0 ave      578518 max      578518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578518
Ave neighs/atom = 144.62950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.817132485168, Press = -0.298422669458155
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -11556.961   -11556.961   -11717.758   -11717.758    311.07207    311.07207    72579.341    72579.341    1619.5697    1619.5697 
   14000    -11555.06    -11555.06   -11720.302   -11720.302    319.67099    319.67099    72758.488    72758.488    -1023.857    -1023.857 
Loop time of 84.9314 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.017 ns/day, 23.592 hours/ns, 11.774 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    | 83.806     | 83.806     | 83.806     |   0.0 | 98.67
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21901    | 0.21901    | 0.21901    |   0.0 |  0.26
Output  | 0.0001828  | 0.0001828  | 0.0001828  |   0.0 |  0.00
Modify  | 0.8026     | 0.8026     | 0.8026     |   0.0 |  0.94
Other   |            | 0.1041     |            |       |  0.12

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      579986.0 ave      579986 max      579986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 579986
Ave neighs/atom = 144.99650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.816186077602, Press = -3.03440981524495
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000    -11555.06    -11555.06   -11720.302   -11720.302    319.67099    319.67099    72758.488    72758.488    -1023.857    -1023.857 
   15000   -11556.301   -11556.301    -11720.95    -11720.95    318.52631    318.52631    72711.574    72711.574   -353.92547   -353.92547 
Loop time of 66.1591 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.306 ns/day, 18.378 hours/ns, 15.115 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    | 65.198     | 65.198     | 65.198     |   0.0 | 98.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1931     | 0.1931     | 0.1931     |   0.0 |  0.29
Output  | 0.00049286 | 0.00049286 | 0.00049286 |   0.0 |  0.00
Modify  | 0.66828    | 0.66828    | 0.66828    |   0.0 |  1.01
Other   |            | 0.09948    |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      577776.0 ave      577776 max      577776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 577776
Ave neighs/atom = 144.44400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.868737690844, Press = 1.47481634323643
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -11556.301   -11556.301    -11720.95    -11720.95    318.52631    318.52631    72711.574    72711.574   -353.92547   -353.92547 
   16000   -11566.829   -11566.829   -11723.724   -11723.724    303.52328    303.52328    72626.009    72626.009    543.92934    543.92934 
Loop time of 63.2527 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.366 ns/day, 17.570 hours/ns, 15.810 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    | 62.296     | 62.296     | 62.296     |   0.0 | 98.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18865    | 0.18865    | 0.18865    |   0.0 |  0.30
Output  | 0.00017741 | 0.00017741 | 0.00017741 |   0.0 |  0.00
Modify  | 0.66724    | 0.66724    | 0.66724    |   0.0 |  1.05
Other   |            | 0.1006     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      577562.0 ave      577562 max      577562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 577562
Ave neighs/atom = 144.39050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.765414988656, Press = 2.42294372980876
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -11566.829   -11566.829   -11723.724   -11723.724    303.52328    303.52328    72626.009    72626.009    543.92934    543.92934 
   17000    -11557.87    -11557.87   -11721.361   -11721.361    316.28362    316.28362     72699.09     72699.09   -287.09157   -287.09157 
Loop time of 63.48 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.361 ns/day, 17.633 hours/ns, 15.753 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.521     | 62.521     | 62.521     |   0.0 | 98.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19065    | 0.19065    | 0.19065    |   0.0 |  0.30
Output  | 0.00017776 | 0.00017776 | 0.00017776 |   0.0 |  0.00
Modify  | 0.66735    | 0.66735    | 0.66735    |   0.0 |  1.05
Other   |            | 0.101      |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578476.0 ave      578476 max      578476 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578476
Ave neighs/atom = 144.61900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.714971482782, Press = -0.25932980436179
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000    -11557.87    -11557.87   -11721.361   -11721.361    316.28362    316.28362     72699.09     72699.09   -287.09157   -287.09157 
   18000   -11560.666   -11560.666   -11721.896   -11721.896    311.90979    311.90979    72689.323    72689.323    -196.3511    -196.3511 
Loop time of 80.7628 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.070 ns/day, 22.434 hours/ns, 12.382 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    | 79.59      | 79.59      | 79.59      |   0.0 | 98.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22168    | 0.22168    | 0.22168    |   0.0 |  0.27
Output  | 0.00027378 | 0.00027378 | 0.00027378 |   0.0 |  0.00
Modify  | 0.84065    | 0.84065    | 0.84065    |   0.0 |  1.04
Other   |            | 0.1101     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578316.0 ave      578316 max      578316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578316
Ave neighs/atom = 144.57900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.724730644159, Press = 2.23025366352522
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -11560.666   -11560.666   -11721.896   -11721.896    311.90979    311.90979    72689.323    72689.323    -196.3511    -196.3511 
   19000   -11559.949   -11559.949   -11721.389   -11721.389    312.31556    312.31556    72603.892    72603.892    1029.1452    1029.1452 
Loop time of 81.642 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.058 ns/day, 22.678 hours/ns, 12.249 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 80.454     | 80.454     | 80.454     |   0.0 | 98.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22373    | 0.22373    | 0.22373    |   0.0 |  0.27
Output  | 0.00017912 | 0.00017912 | 0.00017912 |   0.0 |  0.00
Modify  | 0.85317    | 0.85317    | 0.85317    |   0.0 |  1.05
Other   |            | 0.1107     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578294.0 ave      578294 max      578294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578294
Ave neighs/atom = 144.57350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.726390157381, Press = 0.044480734980542
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -11559.949   -11559.949   -11721.389   -11721.389    312.31556    312.31556    72603.892    72603.892    1029.1452    1029.1452 
   20000   -11559.012   -11559.012   -11722.932   -11722.932    317.11433    317.11433    72751.873    72751.873    -1037.688    -1037.688 
Loop time of 70.2215 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.230 ns/day, 19.506 hours/ns, 14.241 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    | 69.231     | 69.231     | 69.231     |   0.0 | 98.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19702    | 0.19702    | 0.19702    |   0.0 |  0.28
Output  | 0.00018129 | 0.00018129 | 0.00018129 |   0.0 |  0.00
Modify  | 0.69329    | 0.69329    | 0.69329    |   0.0 |  0.99
Other   |            | 0.1004     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8193.00 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578836.0 ave      578836 max      578836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578836
Ave neighs/atom = 144.70900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.637923623192, Press = -0.488767862036873
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -11559.012   -11559.012   -11722.932   -11722.932    317.11433    317.11433    72751.873    72751.873    -1037.688    -1037.688 
   21000   -11555.813   -11555.813   -11720.061   -11720.061    317.74835    317.74835    72708.927    72708.927   -304.40193   -304.40193 
Loop time of 80.0293 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.080 ns/day, 22.230 hours/ns, 12.495 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 78.937     | 78.937     | 78.937     |   0.0 | 98.63
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21416    | 0.21416    | 0.21416    |   0.0 |  0.27
Output  | 0.00017777 | 0.00017777 | 0.00017777 |   0.0 |  0.00
Modify  | 0.77488    | 0.77488    | 0.77488    |   0.0 |  0.97
Other   |            | 0.1032     |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      577136.0 ave      577136 max      577136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 577136
Ave neighs/atom = 144.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 = 312.584748521892, Press = 2.4179798989064
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -11555.813   -11555.813   -11720.061   -11720.061    317.74835    317.74835    72708.927    72708.927   -304.40193   -304.40193 
   22000   -11560.173   -11560.173   -11721.739   -11721.739    312.55997    312.55997    72608.858    72608.858     992.7176     992.7176 
Loop time of 76.4619 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.130 ns/day, 21.239 hours/ns, 13.078 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 75.379     | 75.379     | 75.379     |   0.0 | 98.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21052    | 0.21052    | 0.21052    |   0.0 |  0.28
Output  | 0.00023717 | 0.00023717 | 0.00023717 |   0.0 |  0.00
Modify  | 0.76777    | 0.76777    | 0.76777    |   0.0 |  1.00
Other   |            | 0.104      |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578416.0 ave      578416 max      578416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578416
Ave neighs/atom = 144.60400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.589600818, Press = 0.0986859105255442
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -11560.173   -11560.173   -11721.739   -11721.739    312.55997    312.55997    72608.858    72608.858     992.7176     992.7176 
   23000   -11558.197   -11558.197    -11719.58    -11719.58    312.20621    312.20621    72854.991    72854.991   -2358.3035   -2358.3035 
Loop time of 63.7758 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.355 ns/day, 17.715 hours/ns, 15.680 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.812     | 62.812     | 62.812     |   0.0 | 98.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19071    | 0.19071    | 0.19071    |   0.0 |  0.30
Output  | 0.00017915 | 0.00017915 | 0.00017915 |   0.0 |  0.00
Modify  | 0.67138    | 0.67138    | 0.67138    |   0.0 |  1.05
Other   |            | 0.1011     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578748.0 ave      578748 max      578748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578748
Ave neighs/atom = 144.68700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.603821017811, Press = -1.37557034293866
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -11558.197   -11558.197    -11719.58    -11719.58    312.20621    312.20621    72854.991    72854.991   -2358.3035   -2358.3035 
   24000     -11558.2     -11558.2   -11720.686   -11720.686    314.33907    314.33907    72684.683    72684.683    3.5050552    3.5050552 
Loop time of 68.1516 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.268 ns/day, 18.931 hours/ns, 14.673 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 67.191     | 67.191     | 67.191     |   0.0 | 98.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19472    | 0.19472    | 0.19472    |   0.0 |  0.29
Output  | 0.00017584 | 0.00017584 | 0.00017584 |   0.0 |  0.00
Modify  | 0.66718    | 0.66718    | 0.66718    |   0.0 |  0.98
Other   |            | 0.09864    |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      576656.0 ave      576656 max      576656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 576656
Ave neighs/atom = 144.16400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.576303890819, Press = 1.92891803252181
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000     -11558.2     -11558.2   -11720.686   -11720.686    314.33907    314.33907    72684.683    72684.683    3.5050552    3.5050552 
   25000   -11559.738   -11559.738   -11719.826   -11719.826    309.70199    309.70199    72650.032    72650.032    499.92482    499.92482 
Loop time of 67.5416 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.279 ns/day, 18.762 hours/ns, 14.806 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 66.583     | 66.583     | 66.583     |   0.0 | 98.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19418    | 0.19418    | 0.19418    |   0.0 |  0.29
Output  | 0.00017709 | 0.00017709 | 0.00017709 |   0.0 |  0.00
Modify  | 0.66567    | 0.66567    | 0.66567    |   0.0 |  0.99
Other   |            | 0.0991     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578394.0 ave      578394 max      578394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578394
Ave neighs/atom = 144.59850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.601070836195, Press = -1.15901455263204
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -11559.738   -11559.738   -11719.826   -11719.826    309.70199    309.70199    72650.032    72650.032    499.92482    499.92482 
   26000   -11564.799   -11564.799   -11725.392   -11725.392    310.67721    310.67721    72711.335    72711.335   -699.36864   -699.36864 
Loop time of 63.395 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.363 ns/day, 17.610 hours/ns, 15.774 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.432     | 62.432     | 62.432     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19084    | 0.19084    | 0.19084    |   0.0 |  0.30
Output  | 0.00017737 | 0.00017737 | 0.00017737 |   0.0 |  0.00
Modify  | 0.67103    | 0.67103    | 0.67103    |   0.0 |  1.06
Other   |            | 0.1013     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578994.0 ave      578994 max      578994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578994
Ave neighs/atom = 144.74850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.499623843879, Press = 0.549979289772303
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -11564.799   -11564.799   -11725.392   -11725.392    310.67721    310.67721    72711.335    72711.335   -699.36864   -699.36864 
   27000   -11558.679   -11558.679   -11722.872   -11722.872    317.64157    317.64157    72625.338    72625.338    753.37842    753.37842 
Loop time of 63.3355 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.364 ns/day, 17.593 hours/ns, 15.789 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.372     | 62.372     | 62.372     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19086    | 0.19086    | 0.19086    |   0.0 |  0.30
Output  | 0.00017715 | 0.00017715 | 0.00017715 |   0.0 |  0.00
Modify  | 0.67033    | 0.67033    | 0.67033    |   0.0 |  1.06
Other   |            | 0.102      |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8191.00 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      577514.0 ave      577514 max      577514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 577514
Ave neighs/atom = 144.37850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.523642145136, Press = 1.50330088933654
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -11558.679   -11558.679   -11722.872   -11722.872    317.64157    317.64157    72625.338    72625.338    753.37842    753.37842 
   28000   -11559.421   -11559.421   -11722.397   -11722.397    315.28821    315.28821     72729.59     72729.59   -803.58492   -803.58492 
Loop time of 63.3383 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.364 ns/day, 17.594 hours/ns, 15.788 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.375     | 62.375     | 62.375     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19196    | 0.19196    | 0.19196    |   0.0 |  0.30
Output  | 0.00023331 | 0.00023331 | 0.00023331 |   0.0 |  0.00
Modify  | 0.66918    | 0.66918    | 0.66918    |   0.0 |  1.06
Other   |            | 0.1019     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8193.00 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578642.0 ave      578642 max      578642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578642
Ave neighs/atom = 144.66050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.572986273328, Press = -0.189133814944394
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -11559.421   -11559.421   -11722.397   -11722.397    315.28821    315.28821     72729.59     72729.59   -803.58492   -803.58492 
   29000   -11555.814   -11555.814   -11719.416   -11719.416     316.4991     316.4991    72734.152    72734.152   -636.64455   -636.64455 
Loop time of 63.3458 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.364 ns/day, 17.596 hours/ns, 15.786 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.383     | 62.383     | 62.383     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19125    | 0.19125    | 0.19125    |   0.0 |  0.30
Output  | 0.000177   | 0.000177   | 0.000177   |   0.0 |  0.00
Modify  | 0.66913    | 0.66913    | 0.66913    |   0.0 |  1.06
Other   |            | 0.1019     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8194.00 ave        8194 max        8194 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578132.0 ave      578132 max      578132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578132
Ave neighs/atom = 144.53300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.644653262708, Press = 1.60064012143453
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -11555.814   -11555.814   -11719.416   -11719.416     316.4991     316.4991    72734.152    72734.152   -636.64455   -636.64455 
   30000   -11558.281   -11558.281   -11719.606   -11719.606    312.09454    312.09454     72577.08     72577.08    1493.6684    1493.6684 
Loop time of 63.3725 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.363 ns/day, 17.603 hours/ns, 15.780 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.409     | 62.409     | 62.409     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19126    | 0.19126    | 0.19126    |   0.0 |  0.30
Output  | 0.00017805 | 0.00017805 | 0.00017805 |   0.0 |  0.00
Modify  | 0.67068    | 0.67068    | 0.67068    |   0.0 |  1.06
Other   |            | 0.1018     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578032.0 ave      578032 max      578032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578032
Ave neighs/atom = 144.50800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.688622983513, Press = 0.738417324270253
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -11558.281   -11558.281   -11719.606   -11719.606    312.09454    312.09454     72577.08     72577.08    1493.6684    1493.6684 
   31000   -11562.595   -11562.595   -11723.543   -11723.543    311.36565    311.36565    72642.076    72642.076    352.83984    352.83984 
Loop time of 63.3967 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.363 ns/day, 17.610 hours/ns, 15.774 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.433     | 62.433     | 62.433     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19102    | 0.19102    | 0.19102    |   0.0 |  0.30
Output  | 0.00017861 | 0.00017861 | 0.00017861 |   0.0 |  0.00
Modify  | 0.67046    | 0.67046    | 0.67046    |   0.0 |  1.06
Other   |            | 0.1018     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      579256.0 ave      579256 max      579256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 579256
Ave neighs/atom = 144.81400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.720064974127, Press = -0.154617452010933
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -11562.595   -11562.595   -11723.543   -11723.543    311.36565    311.36565    72642.076    72642.076    352.83984    352.83984 
   32000   -11557.816   -11557.816   -11716.847   -11716.847    307.65579    307.65579    72720.331    72720.331   -397.27568   -397.27568 
Loop time of 63.4051 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.363 ns/day, 17.613 hours/ns, 15.772 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.442     | 62.442     | 62.442     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19099    | 0.19099    | 0.19099    |   0.0 |  0.30
Output  | 0.00023369 | 0.00023369 | 0.00023369 |   0.0 |  0.00
Modify  | 0.66985    | 0.66985    | 0.66985    |   0.0 |  1.06
Other   |            | 0.1018     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578510.0 ave      578510 max      578510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578510
Ave neighs/atom = 144.62750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.782398298844, Press = 0.868876618411433
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -11557.816   -11557.816   -11716.847   -11716.847    307.65579    307.65579    72720.331    72720.331   -397.27568   -397.27568 
   33000   -11560.531   -11560.531   -11722.625   -11722.625    313.58051    313.58051    72522.928    72522.928     2131.802     2131.802 
Loop time of 63.3969 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.363 ns/day, 17.610 hours/ns, 15.774 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.433     | 62.433     | 62.433     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19147    | 0.19147    | 0.19147    |   0.0 |  0.30
Output  | 0.00017754 | 0.00017754 | 0.00017754 |   0.0 |  0.00
Modify  | 0.67036    | 0.67036    | 0.67036    |   0.0 |  1.06
Other   |            | 0.102      |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578394.0 ave      578394 max      578394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578394
Ave neighs/atom = 144.59850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.782716802357, Press = 0.9320204626578
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -11560.531   -11560.531   -11722.625   -11722.625    313.58051    313.58051    72522.928    72522.928     2131.802     2131.802 
   34000    -11557.98    -11557.98   -11720.679   -11720.679    314.75097    314.75097     72752.35     72752.35   -958.79365   -958.79365 
Loop time of 63.3922 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.363 ns/day, 17.609 hours/ns, 15.775 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.429     | 62.429     | 62.429     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19077    | 0.19077    | 0.19077    |   0.0 |  0.30
Output  | 0.00017884 | 0.00017884 | 0.00017884 |   0.0 |  0.00
Modify  | 0.67116    | 0.67116    | 0.67116    |   0.0 |  1.06
Other   |            | 0.1013     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      579760.0 ave      579760 max      579760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 579760
Ave neighs/atom = 144.94000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.75218203325, Press = -0.820661597717157
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000    -11557.98    -11557.98   -11720.679   -11720.679    314.75097    314.75097     72752.35     72752.35   -958.79365   -958.79365 
   35000   -11564.176   -11564.176    -11722.26    -11722.26    305.82555    305.82555    72679.923    72679.923   -104.09861   -104.09861 
Loop time of 63.3304 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.364 ns/day, 17.592 hours/ns, 15.790 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.367     | 62.367     | 62.367     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19089    | 0.19089    | 0.19089    |   0.0 |  0.30
Output  | 0.00017991 | 0.00017991 | 0.00017991 |   0.0 |  0.00
Modify  | 0.67071    | 0.67071    | 0.67071    |   0.0 |  1.06
Other   |            | 0.1016     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      577706.0 ave      577706 max      577706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 577706
Ave neighs/atom = 144.42650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.713210261233, Press = 1.1167033964689
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -11564.176   -11564.176    -11722.26    -11722.26    305.82555    305.82555    72679.923    72679.923   -104.09861   -104.09861 
   36000   -11558.695   -11558.695   -11720.415   -11720.415    312.85889    312.85889    72622.546    72622.546    779.76919    779.76919 
Loop time of 81.0699 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.066 ns/day, 22.519 hours/ns, 12.335 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    | 79.943     | 79.943     | 79.943     |   0.0 | 98.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21946    | 0.21946    | 0.21946    |   0.0 |  0.27
Output  | 0.00018431 | 0.00018431 | 0.00018431 |   0.0 |  0.00
Modify  | 0.80143    | 0.80143    | 0.80143    |   0.0 |  0.99
Other   |            | 0.1061     |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8193.00 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578454.0 ave      578454 max      578454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578454
Ave neighs/atom = 144.61350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.746477163301, Press = 0.161629200567164
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -11558.695   -11558.695   -11720.415   -11720.415    312.85889    312.85889    72622.546    72622.546    779.76919    779.76919 
   37000   -11559.832   -11559.832   -11720.876   -11720.876    311.55001    311.55001    72708.101    72708.101   -341.96022   -341.96022 
Loop time of 88.0903 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.981 ns/day, 24.470 hours/ns, 11.352 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    | 86.895     | 86.895     | 86.895     |   0.0 | 98.64
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.2312     | 0.2312     | 0.2312     |   0.0 |  0.26
Output  | 0.00018163 | 0.00018163 | 0.00018163 |   0.0 |  0.00
Modify  | 0.85514    | 0.85514    | 0.85514    |   0.0 |  0.97
Other   |            | 0.1084     |            |       |  0.12

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      579418.0 ave      579418 max      579418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 579418
Ave neighs/atom = 144.85450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.732148879458, Press = -0.325277466053464
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -11559.832   -11559.832   -11720.876   -11720.876    311.55001    311.55001    72708.101    72708.101   -341.96022   -341.96022 
   38000   -11561.079   -11561.079   -11720.349   -11720.349    308.11853    308.11853    72737.983    72737.983   -846.81483   -846.81483 
Loop time of 74.0182 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.167 ns/day, 20.561 hours/ns, 13.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    | 72.954     | 72.954     | 72.954     |   0.0 | 98.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20797    | 0.20797    | 0.20797    |   0.0 |  0.28
Output  | 0.0002388  | 0.0002388  | 0.0002388  |   0.0 |  0.00
Modify  | 0.75103    | 0.75103    | 0.75103    |   0.0 |  1.01
Other   |            | 0.1046     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8191.00 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578266.0 ave      578266 max      578266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578266
Ave neighs/atom = 144.56650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.726815238481, Press = 1.57125682782622
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -11561.079   -11561.079   -11720.349   -11720.349    308.11853    308.11853    72737.983    72737.983   -846.81483   -846.81483 
   39000   -11561.804   -11561.804   -11723.157   -11723.157    312.14806    312.14806    72624.174    72624.174    634.97212    634.97212 
Loop time of 63.2244 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.367 ns/day, 17.562 hours/ns, 15.817 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    | 62.255     | 62.255     | 62.255     |   0.0 | 98.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19332    | 0.19332    | 0.19332    |   0.0 |  0.31
Output  | 0.00017785 | 0.00017785 | 0.00017785 |   0.0 |  0.00
Modify  | 0.67249    | 0.67249    | 0.67249    |   0.0 |  1.06
Other   |            | 0.1031     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      577992.0 ave      577992 max      577992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 577992
Ave neighs/atom = 144.49800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.731212734733, Press = 0.556580415541678
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -11561.804   -11561.804   -11723.157   -11723.157    312.14806    312.14806    72624.174    72624.174    634.97212    634.97212 
   40000   -11556.874   -11556.874   -11720.916   -11720.916    317.34905    317.34905    72703.539    72703.539    -240.1283    -240.1283 
Loop time of 63.2752 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.365 ns/day, 17.576 hours/ns, 15.804 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    | 62.307     | 62.307     | 62.307     |   0.0 | 98.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19285    | 0.19285    | 0.19285    |   0.0 |  0.30
Output  | 0.00017622 | 0.00017622 | 0.00017622 |   0.0 |  0.00
Modify  | 0.67336    | 0.67336    | 0.67336    |   0.0 |  1.06
Other   |            | 0.1014     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8194.00 ave        8194 max        8194 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578962.0 ave      578962 max      578962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578962
Ave neighs/atom = 144.74050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.787064591666, Press = 0.332103722795181
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -11556.874   -11556.874   -11720.916   -11720.916    317.34905    317.34905    72703.539    72703.539    -240.1283    -240.1283 
   41000   -11560.556   -11560.556   -11722.147   -11722.147    312.60996    312.60996    72702.605    72702.605   -408.04488   -408.04488 
Loop time of 79.5831 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.086 ns/day, 22.106 hours/ns, 12.565 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    | 78.477     | 78.477     | 78.477     |   0.0 | 98.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21463    | 0.21463    | 0.21463    |   0.0 |  0.27
Output  | 0.00053182 | 0.00053182 | 0.00053182 |   0.0 |  0.00
Modify  | 0.78399    | 0.78399    | 0.78399    |   0.0 |  0.99
Other   |            | 0.107      |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578390.0 ave      578390 max      578390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578390
Ave neighs/atom = 144.59750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.818791161356, Press = 0.236572271774893
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -11560.556   -11560.556   -11722.147   -11722.147    312.60996    312.60996    72702.605    72702.605   -408.04488   -408.04488 
   42000   -11563.731   -11563.731   -11724.313   -11724.313    310.65596    310.65596    72738.888    72738.888     -1048.29     -1048.29 
Loop time of 90.958 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.950 ns/day, 25.266 hours/ns, 10.994 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    | 89.736     | 89.736     | 89.736     |   0.0 | 98.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.23601    | 0.23601    | 0.23601    |   0.0 |  0.26
Output  | 0.00018202 | 0.00018202 | 0.00018202 |   0.0 |  0.00
Modify  | 0.87423    | 0.87423    | 0.87423    |   0.0 |  0.96
Other   |            | 0.1116     |            |       |  0.12

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8191.00 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578442.0 ave      578442 max      578442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578442
Ave neighs/atom = 144.61050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.773815309309, Press = 0.115671252819542
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -11563.731   -11563.731   -11724.313   -11724.313    310.65596    310.65596    72738.888    72738.888     -1048.29     -1048.29 
   43000   -11561.243   -11561.243    -11721.78    -11721.78    310.57073    310.57073    72677.059    72677.059    9.9241212    9.9241212 
Loop time of 85.247 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.014 ns/day, 23.680 hours/ns, 11.731 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    | 84.064     | 84.064     | 84.064     |   0.0 | 98.61
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.22975    | 0.22975    | 0.22975    |   0.0 |  0.27
Output  | 0.0001893  | 0.0001893  | 0.0001893  |   0.0 |  0.00
Modify  | 0.84451    | 0.84451    | 0.84451    |   0.0 |  0.99
Other   |            | 0.1088     |            |       |  0.13

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578078.0 ave      578078 max      578078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578078
Ave neighs/atom = 144.51950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.752633430173, Press = 1.02794125120773
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -11561.243   -11561.243    -11721.78    -11721.78    310.57073    310.57073    72677.059    72677.059    9.9241212    9.9241212 
   44000   -11556.227   -11556.227   -11723.595   -11723.595     323.7838     323.7838    72648.037    72648.037    373.62688    373.62688 
Loop time of 63.3994 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.363 ns/day, 17.611 hours/ns, 15.773 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.438     | 62.438     | 62.438     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19124    | 0.19124    | 0.19124    |   0.0 |  0.30
Output  | 0.00017709 | 0.00017709 | 0.00017709 |   0.0 |  0.00
Modify  | 0.66874    | 0.66874    | 0.66874    |   0.0 |  1.05
Other   |            | 0.1015     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8191.00 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578448.0 ave      578448 max      578448 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578448
Ave neighs/atom = 144.61200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.746581308588, Press = 0.115437562270642
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -11556.227   -11556.227   -11723.595   -11723.595     323.7838     323.7838    72648.037    72648.037    373.62688    373.62688 
   45000   -11559.868   -11559.868   -11723.254   -11723.254    316.08154    316.08154    72708.024    72708.024   -589.93738   -589.93738 
Loop time of 63.3142 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.365 ns/day, 17.587 hours/ns, 15.794 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    | 62.353     | 62.353     | 62.353     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19121    | 0.19121    | 0.19121    |   0.0 |  0.30
Output  | 0.00017802 | 0.00017802 | 0.00017802 |   0.0 |  0.00
Modify  | 0.66861    | 0.66861    | 0.66861    |   0.0 |  1.06
Other   |            | 0.1012     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578278.0 ave      578278 max      578278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578278
Ave neighs/atom = 144.56950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.751522716671, Press = -0.304257228345302
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -11559.868   -11559.868   -11723.254   -11723.254    316.08154    316.08154    72708.024    72708.024   -589.93738   -589.93738 
   46000   -11554.797   -11554.797   -11718.692   -11718.692    317.06522    317.06522    72815.072    72815.072    -1724.359    -1724.359 
Loop time of 66.9335 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.291 ns/day, 18.593 hours/ns, 14.940 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    | 65.943     | 65.943     | 65.943     |   0.0 | 98.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19533    | 0.19533    | 0.19533    |   0.0 |  0.29
Output  | 0.00017946 | 0.00017946 | 0.00017946 |   0.0 |  0.00
Modify  | 0.69235    | 0.69235    | 0.69235    |   0.0 |  1.03
Other   |            | 0.1022     |            |       |  0.15

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578166.0 ave      578166 max      578166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578166
Ave neighs/atom = 144.54150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.778617740848, Press = 1.01824554761134
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -11554.797   -11554.797   -11718.692   -11718.692    317.06522    317.06522    72815.072    72815.072    -1724.359    -1724.359 
   47000    -11559.61    -11559.61    -11723.09    -11723.09    316.26278    316.26278    72556.085    72556.085    1584.7356    1584.7356 
Loop time of 63.437 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.362 ns/day, 17.621 hours/ns, 15.764 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    | 62.474     | 62.474     | 62.474     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19257    | 0.19257    | 0.19257    |   0.0 |  0.30
Output  | 0.00017926 | 0.00017926 | 0.00017926 |   0.0 |  0.00
Modify  | 0.66766    | 0.66766    | 0.66766    |   0.0 |  1.05
Other   |            | 0.1026     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      577694.0 ave      577694 max      577694 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 577694
Ave neighs/atom = 144.42350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.83556854266, Press = 0.888688402916756
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000    -11559.61    -11559.61    -11723.09    -11723.09    316.26278    316.26278    72556.085    72556.085    1584.7356    1584.7356 
   48000   -11564.262   -11564.262    -11723.83    -11723.83    308.69534    308.69534    72683.673    72683.673    -244.8244    -244.8244 
Loop time of 63.5286 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.360 ns/day, 17.647 hours/ns, 15.741 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.565     | 62.565     | 62.565     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19167    | 0.19167    | 0.19167    |   0.0 |  0.30
Output  | 0.00017718 | 0.00017718 | 0.00017718 |   0.0 |  0.00
Modify  | 0.66936    | 0.66936    | 0.66936    |   0.0 |  1.05
Other   |            | 0.1023     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      579830.0 ave      579830 max      579830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 579830
Ave neighs/atom = 144.95750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.853354375223, Press = 0.0419704799012826
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -11564.262   -11564.262    -11723.83    -11723.83    308.69534    308.69534    72683.673    72683.673    -244.8244    -244.8244 
   49000   -11561.834   -11561.834   -11720.565   -11720.565    307.07546    307.07546    72666.886    72666.886    208.19416    208.19416 
Loop time of 63.4121 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.363 ns/day, 17.614 hours/ns, 15.770 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.449     | 62.449     | 62.449     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19163    | 0.19163    | 0.19163    |   0.0 |  0.30
Output  | 0.00017766 | 0.00017766 | 0.00017766 |   0.0 |  0.00
Modify  | 0.66944    | 0.66944    | 0.66944    |   0.0 |  1.06
Other   |            | 0.1022     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578098.0 ave      578098 max      578098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578098
Ave neighs/atom = 144.52450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.852894382726, Press = 0.655339967468126
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -11561.834   -11561.834   -11720.565   -11720.565    307.07546    307.07546    72666.886    72666.886    208.19416    208.19416 
   50000    -11559.95    -11559.95   -11721.647   -11721.647    312.81487    312.81487    72627.004    72627.004    637.09665    637.09665 
Loop time of 63.5311 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.360 ns/day, 17.648 hours/ns, 15.740 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    | 62.567     | 62.567     | 62.567     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19191    | 0.19191    | 0.19191    |   0.0 |  0.30
Output  | 0.00017846 | 0.00017846 | 0.00017846 |   0.0 |  0.00
Modify  | 0.66849    | 0.66849    | 0.66849    |   0.0 |  1.05
Other   |            | 0.1033     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578462.0 ave      578462 max      578462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578462
Ave neighs/atom = 144.61550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.868119412693, Press = 0.606508516709332
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000    -11559.95    -11559.95   -11721.647   -11721.647    312.81487    312.81487    72627.004    72627.004    637.09665    637.09665 
   51000   -11560.326   -11560.326   -11720.444   -11720.444    309.75765    309.75765    72660.113    72660.113    223.57081    223.57081 
Loop time of 63.5113 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.360 ns/day, 17.642 hours/ns, 15.745 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    | 62.549     | 62.549     | 62.549     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19113    | 0.19113    | 0.19113    |   0.0 |  0.30
Output  | 0.00017782 | 0.00017782 | 0.00017782 |   0.0 |  0.00
Modify  | 0.66858    | 0.66858    | 0.66858    |   0.0 |  1.05
Other   |            | 0.1029     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578906.0 ave      578906 max      578906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578906
Ave neighs/atom = 144.72650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.830806951829, Press = -0.103559000829736
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -11560.326   -11560.326   -11720.444   -11720.444    309.75765    309.75765    72660.113    72660.113    223.57081    223.57081 
   52000   -11558.043   -11558.043   -11720.334   -11720.334    313.96269    313.96269    72740.838    72740.838   -780.72065   -780.72065 
Loop time of 74.7059 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.157 ns/day, 20.752 hours/ns, 13.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    | 73.642     | 73.642     | 73.642     |   0.0 | 98.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20807    | 0.20807    | 0.20807    |   0.0 |  0.28
Output  | 0.00024542 | 0.00024542 | 0.00024542 |   0.0 |  0.00
Modify  | 0.75115    | 0.75115    | 0.75115    |   0.0 |  1.01
Other   |            | 0.1046     |            |       |  0.14

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      579194.0 ave      579194 max      579194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 579194
Ave neighs/atom = 144.79850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.839704925782, Press = 0.144951142062001
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -11558.043   -11558.043   -11720.334   -11720.334    313.96269    313.96269    72740.838    72740.838   -780.72065   -780.72065 
   53000   -11562.911   -11562.911   -11723.981   -11723.981    311.60127    311.60127    72694.401    72694.401    -358.9273    -358.9273 
Loop time of 91.1345 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.948 ns/day, 25.315 hours/ns, 10.973 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 89.911     | 89.911     | 89.911     |   0.0 | 98.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.23675    | 0.23675    | 0.23675    |   0.0 |  0.26
Output  | 0.0002407  | 0.0002407  | 0.0002407  |   0.0 |  0.00
Modify  | 0.87744    | 0.87744    | 0.87744    |   0.0 |  0.96
Other   |            | 0.1088     |            |       |  0.12

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578120.0 ave      578120 max      578120 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578120
Ave neighs/atom = 144.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 = 312.827852590361, Press = 0.687589223802663
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -11562.911   -11562.911   -11723.981   -11723.981    311.60127    311.60127    72694.401    72694.401    -358.9273    -358.9273 
   54000   -11555.642   -11555.642   -11719.149   -11719.149    316.31677    316.31677    72582.519    72582.519    1535.0375    1535.0375 
Loop time of 84.0354 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.028 ns/day, 23.343 hours/ns, 11.900 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    | 82.966     | 82.966     | 82.966     |   0.0 | 98.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.21877    | 0.21877    | 0.21877    |   0.0 |  0.26
Output  | 0.00018283 | 0.00018283 | 0.00018283 |   0.0 |  0.00
Modify  | 0.74976    | 0.74976    | 0.74976    |   0.0 |  0.89
Other   |            | 0.1011     |            |       |  0.12

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      577712.0 ave      577712 max      577712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 577712
Ave neighs/atom = 144.42800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.805779919568, Press = 0.620102016968322
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -11555.642   -11555.642   -11719.149   -11719.149    316.31677    316.31677    72582.519    72582.519    1535.0375    1535.0375 
   55000   -11562.223   -11562.223   -11719.771   -11719.771    304.78828    304.78828    72697.149    72697.149   -260.25471   -260.25471 
Loop time of 80.8759 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.068 ns/day, 22.466 hours/ns, 12.365 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    | 79.879     | 79.879     | 79.879     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20625    | 0.20625    | 0.20625    |   0.0 |  0.26
Output  | 0.00017148 | 0.00017148 | 0.00017148 |   0.0 |  0.00
Modify  | 0.69256    | 0.69256    | 0.69256    |   0.0 |  0.86
Other   |            | 0.09833    |            |       |  0.12

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      579548.0 ave      579548 max      579548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 579548
Ave neighs/atom = 144.88700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.813285546942, Press = -0.285586654324229
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -11562.223   -11562.223   -11719.771   -11719.771    304.78828    304.78828    72697.149    72697.149   -260.25471   -260.25471 
   56000   -11560.567   -11560.567   -11724.824   -11724.824    317.76724    317.76724    72688.338    72688.338   -303.62285   -303.62285 
Loop time of 81.0779 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.066 ns/day, 22.522 hours/ns, 12.334 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    | 80.081     | 80.081     | 80.081     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20385    | 0.20385    | 0.20385    |   0.0 |  0.25
Output  | 0.0002021  | 0.0002021  | 0.0002021  |   0.0 |  0.00
Modify  | 0.6942     | 0.6942     | 0.6942     |   0.0 |  0.86
Other   |            | 0.09835    |            |       |  0.12

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578794.0 ave      578794 max      578794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578794
Ave neighs/atom = 144.69850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.839021862797, Press = 0.336430632493773
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -11560.567   -11560.567   -11724.824   -11724.824    317.76724    317.76724    72688.338    72688.338   -303.62285   -303.62285 
   57000   -11560.178   -11560.178   -11722.488   -11722.488    313.99955    313.99955    72665.453    72665.453    107.57222    107.57222 
Loop time of 81.02 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.066 ns/day, 22.506 hours/ns, 12.343 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    | 80.021     | 80.021     | 80.021     |   0.0 | 98.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20635    | 0.20635    | 0.20635    |   0.0 |  0.25
Output  | 0.00017171 | 0.00017171 | 0.00017171 |   0.0 |  0.00
Modify  | 0.69457    | 0.69457    | 0.69457    |   0.0 |  0.86
Other   |            | 0.0978     |            |       |  0.12

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      577978.0 ave      577978 max      577978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 577978
Ave neighs/atom = 144.49450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.857630800328, Press = 0.397432262041986
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -11560.178   -11560.178   -11722.488   -11722.488    313.99955    313.99955    72665.453    72665.453    107.57222    107.57222 
   58000   -11558.271   -11558.271   -11719.506   -11719.506    311.92042    311.92042     72678.67     72678.67    102.57612    102.57612 
Loop time of 79.7945 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.083 ns/day, 22.165 hours/ns, 12.532 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    | 78.795     | 78.795     | 78.795     |   0.0 | 98.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.20536    | 0.20536    | 0.20536    |   0.0 |  0.26
Output  | 0.00017636 | 0.00017636 | 0.00017636 |   0.0 |  0.00
Modify  | 0.69513    | 0.69513    | 0.69513    |   0.0 |  0.87
Other   |            | 0.09903    |            |       |  0.12

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578318.0 ave      578318 max      578318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578318
Ave neighs/atom = 144.57950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.890223520824, Press = 0.200302737413067
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -11558.271   -11558.271   -11719.506   -11719.506    311.92042    311.92042     72678.67     72678.67    102.57612    102.57612 
   59000   -11564.329   -11564.329   -11725.602   -11725.602    311.99344    311.99344    72703.919    72703.919   -556.69936   -556.69936 
Loop time of 63.5363 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.360 ns/day, 17.649 hours/ns, 15.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    | 62.569     | 62.569     | 62.569     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1922     | 0.1922     | 0.1922     |   0.0 |  0.30
Output  | 0.00017736 | 0.00017736 | 0.00017736 |   0.0 |  0.00
Modify  | 0.67323    | 0.67323    | 0.67323    |   0.0 |  1.06
Other   |            | 0.1013     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578836.0 ave      578836 max      578836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578836
Ave neighs/atom = 144.70900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.857342372102, Press = -0.0259879772558412
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -11564.329   -11564.329   -11725.602   -11725.602    311.99344    311.99344    72703.919    72703.919   -556.69936   -556.69936 
   60000   -11556.462   -11556.462   -11718.607   -11718.607    313.68034    313.68034    72772.178    72772.178   -1141.6195   -1141.6195 
Loop time of 63.4306 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.362 ns/day, 17.620 hours/ns, 15.765 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    | 62.466     | 62.466     | 62.466     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19139    | 0.19139    | 0.19139    |   0.0 |  0.30
Output  | 0.00017629 | 0.00017629 | 0.00017629 |   0.0 |  0.00
Modify  | 0.67115    | 0.67115    | 0.67115    |   0.0 |  1.06
Other   |            | 0.1017     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      577554.0 ave      577554 max      577554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 577554
Ave neighs/atom = 144.38850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.845707782879, Press = 0.45557786166956
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -11556.462   -11556.462   -11718.607   -11718.607    313.68034    313.68034    72772.178    72772.178   -1141.6195   -1141.6195 
   61000   -11561.608   -11561.608   -11721.439   -11721.439    309.20422    309.20422    72645.865    72645.865    452.31787    452.31787 
Loop time of 63.448 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.362 ns/day, 17.624 hours/ns, 15.761 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    | 62.482     | 62.482     | 62.482     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19378    | 0.19378    | 0.19378    |   0.0 |  0.31
Output  | 0.00017758 | 0.00017758 | 0.00017758 |   0.0 |  0.00
Modify  | 0.6702     | 0.6702     | 0.6702     |   0.0 |  1.06
Other   |            | 0.1021     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8191.00 ave        8191 max        8191 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578158.0 ave      578158 max      578158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578158
Ave neighs/atom = 144.53950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.870976620055, Press = 0.577810766560467
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -11561.608   -11561.608   -11721.439   -11721.439    309.20422    309.20422    72645.865    72645.865    452.31787    452.31787 
   62000   -11554.195   -11554.195   -11721.283   -11721.283    323.24395    323.24395    72605.511    72605.511    1212.7183    1212.7183 
Loop time of 63.3358 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.364 ns/day, 17.593 hours/ns, 15.789 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.377     | 62.377     | 62.377     |   0.0 | 98.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19246    | 0.19246    | 0.19246    |   0.0 |  0.30
Output  | 0.00022441 | 0.00022441 | 0.00022441 |   0.0 |  0.00
Modify  | 0.66621    | 0.66621    | 0.66621    |   0.0 |  1.05
Other   |            | 0.1001     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      579050.0 ave      579050 max      579050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 579050
Ave neighs/atom = 144.76250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.902090935873, Press = -0.238200427768358
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -11554.195   -11554.195   -11721.283   -11721.283    323.24395    323.24395    72605.511    72605.511    1212.7183    1212.7183 
   63000   -11554.979   -11554.979   -11717.313   -11717.313    314.04571    314.04571    72742.263    72742.263   -525.18644   -525.18644 
Loop time of 63.3384 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.364 ns/day, 17.594 hours/ns, 15.788 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.379     | 62.379     | 62.379     |   0.0 | 98.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19155    | 0.19155    | 0.19155    |   0.0 |  0.30
Output  | 0.00017712 | 0.00017712 | 0.00017712 |   0.0 |  0.00
Modify  | 0.66687    | 0.66687    | 0.66687    |   0.0 |  1.05
Other   |            | 0.1008     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      579386.0 ave      579386 max      579386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 579386
Ave neighs/atom = 144.84650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.926923581024, Press = 0.0464920648144818
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -11554.979   -11554.979   -11717.313   -11717.313    314.04571    314.04571    72742.263    72742.263   -525.18644   -525.18644 
   64000   -11557.316   -11557.316   -11722.116   -11722.116    318.81587    318.81587    72703.747    72703.747   -409.79185   -409.79185 
Loop time of 63.4256 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.362 ns/day, 17.618 hours/ns, 15.767 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.465     | 62.465     | 62.465     |   0.0 | 98.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19157    | 0.19157    | 0.19157    |   0.0 |  0.30
Output  | 0.00017894 | 0.00017894 | 0.00017894 |   0.0 |  0.00
Modify  | 0.66793    | 0.66793    | 0.66793    |   0.0 |  1.05
Other   |            | 0.1008     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      577882.0 ave      577882 max      577882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 577882
Ave neighs/atom = 144.47050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.925672769225, Press = 0.489544133110431
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -11557.316   -11557.316   -11722.116   -11722.116    318.81587    318.81587    72703.747    72703.747   -409.79185   -409.79185 
   65000   -11555.527   -11555.527   -11718.769   -11718.769    315.80397    315.80397    72704.577    72704.577   -176.29084   -176.29084 
Loop time of 63.4508 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.362 ns/day, 17.625 hours/ns, 15.760 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.492     | 62.492     | 62.492     |   0.0 | 98.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19091    | 0.19091    | 0.19091    |   0.0 |  0.30
Output  | 0.00022816 | 0.00022816 | 0.00022816 |   0.0 |  0.00
Modify  | 0.66695    | 0.66695    | 0.66695    |   0.0 |  1.05
Other   |            | 0.1006     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578132.0 ave      578132 max      578132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578132
Ave neighs/atom = 144.53300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.938198013876, Press = 0.321052680201912
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -11555.527   -11555.527   -11718.769   -11718.769    315.80397    315.80397    72704.577    72704.577   -176.29084   -176.29084 
   66000   -11563.793   -11563.793   -11723.239   -11723.239    308.45908    308.45908    72620.827    72620.827    631.52903    631.52903 
Loop time of 63.8374 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.353 ns/day, 17.733 hours/ns, 15.665 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    | 62.869     | 62.869     | 62.869     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19326    | 0.19326    | 0.19326    |   0.0 |  0.30
Output  | 0.00017776 | 0.00017776 | 0.00017776 |   0.0 |  0.00
Modify  | 0.67374    | 0.67374    | 0.67374    |   0.0 |  1.06
Other   |            | 0.1017     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8194.00 ave        8194 max        8194 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      577948.0 ave      577948 max      577948 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 577948
Ave neighs/atom = 144.48700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.94613082085, Press = 0.191952326675639
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -11563.793   -11563.793   -11723.239   -11723.239    308.45908    308.45908    72620.827    72620.827    631.52903    631.52903 
   67000    -11556.84    -11556.84   -11719.111   -11719.111    313.92453    313.92453    72697.402    72697.402   -99.696619   -99.696619 
Loop time of 63.4359 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.362 ns/day, 17.621 hours/ns, 15.764 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    | 62.472     | 62.472     | 62.472     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19171    | 0.19171    | 0.19171    |   0.0 |  0.30
Output  | 0.00023021 | 0.00023021 | 0.00023021 |   0.0 |  0.00
Modify  | 0.66976    | 0.66976    | 0.66976    |   0.0 |  1.06
Other   |            | 0.102      |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8192.00 ave        8192 max        8192 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578704.0 ave      578704 max      578704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578704
Ave neighs/atom = 144.67600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.931987944199, Press = -0.0316612938165437
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000    -11556.84    -11556.84   -11719.111   -11719.111    313.92453    313.92453    72697.402    72697.402   -99.696619   -99.696619 
   68000   -11559.545   -11559.545   -11720.126   -11720.126    310.65581    310.65581    72744.127    72744.127   -841.05302   -841.05302 
Loop time of 63.5588 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.359 ns/day, 17.655 hours/ns, 15.733 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.592     | 62.592     | 62.592     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19338    | 0.19338    | 0.19338    |   0.0 |  0.30
Output  | 0.00023535 | 0.00023535 | 0.00023535 |   0.0 |  0.00
Modify  | 0.67157    | 0.67157    | 0.67157    |   0.0 |  1.06
Other   |            | 0.1016     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578266.0 ave      578266 max      578266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578266
Ave neighs/atom = 144.56650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.926994471623, Press = 0.540718480311215
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -11559.545   -11559.545   -11720.126   -11720.126    310.65581    310.65581    72744.127    72744.127   -841.05302   -841.05302 
   69000   -11557.252   -11557.252   -11720.258   -11720.258    315.34564    315.34564    72588.733    72588.733    1349.2402    1349.2402 
Loop time of 63.4038 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.363 ns/day, 17.612 hours/ns, 15.772 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.437     | 62.437     | 62.437     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19326    | 0.19326    | 0.19326    |   0.0 |  0.30
Output  | 0.00017723 | 0.00017723 | 0.00017723 |   0.0 |  0.00
Modify  | 0.67124    | 0.67124    | 0.67124    |   0.0 |  1.06
Other   |            | 0.102      |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      577330.0 ave      577330 max      577330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 577330
Ave neighs/atom = 144.33250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.90844064368, Press = 0.84980550283379
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -11557.252   -11557.252   -11720.258   -11720.258    315.34564    315.34564    72588.733    72588.733    1349.2402    1349.2402 
   70000   -11560.659   -11560.659   -11723.006   -11723.006    314.07134    314.07134    72642.184    72642.184    463.72731    463.72731 
Loop time of 63.5347 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.360 ns/day, 17.649 hours/ns, 15.739 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.571     | 62.571     | 62.571     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19326    | 0.19326    | 0.19326    |   0.0 |  0.30
Output  | 0.00017819 | 0.00017819 | 0.00017819 |   0.0 |  0.00
Modify  | 0.6698     | 0.6698     | 0.6698     |   0.0 |  1.05
Other   |            | 0.1004     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      579176.0 ave      579176 max      579176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 579176
Ave neighs/atom = 144.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 = 312.932609820603, Press = -0.241468974191274
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -11560.659   -11560.659   -11723.006   -11723.006    314.07134    314.07134    72642.184    72642.184    463.72731    463.72731 
   71000    -11554.59    -11554.59   -11720.417   -11720.417    320.80405    320.80405    72728.249    72728.249    -631.1083    -631.1083 
Loop time of 63.7091 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.356 ns/day, 17.697 hours/ns, 15.696 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 62.743     | 62.743     | 62.743     |   0.0 | 98.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.19255    | 0.19255    | 0.19255    |   0.0 |  0.30
Output  | 0.00017782 | 0.00017782 | 0.00017782 |   0.0 |  0.00
Modify  | 0.67234    | 0.67234    | 0.67234    |   0.0 |  1.06
Other   |            | 0.1014     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578464.0 ave      578464 max      578464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578464
Ave neighs/atom = 144.61600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.949060163566, Press = 0.251881576682393
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000    -11554.59    -11554.59   -11720.417   -11720.417    320.80405    320.80405    72728.249    72728.249    -631.1083    -631.1083 
   72000   -11561.712   -11561.712    -11724.83    -11724.83    315.56234    315.56234    72720.402    72720.402   -853.78129   -853.78129 
Loop time of 62.1418 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.390 ns/day, 17.262 hours/ns, 16.092 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    | 61.188     | 61.188     | 61.188     |   0.0 | 98.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18691    | 0.18691    | 0.18691    |   0.0 |  0.30
Output  | 0.00017783 | 0.00017783 | 0.00017783 |   0.0 |  0.00
Modify  | 0.66517    | 0.66517    | 0.66517    |   0.0 |  1.07
Other   |            | 0.1014     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8193.00 ave        8193 max        8193 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      577968.0 ave      577968 max      577968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 577968
Ave neighs/atom = 144.49200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.954847075838, Press = 0.280013330522997
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -11561.712   -11561.712    -11724.83    -11724.83    315.56234    315.56234    72720.402    72720.402   -853.78129   -853.78129 
   73000   -11556.493   -11556.493   -11718.517   -11718.517    313.44694    313.44694    72667.608    72667.608    337.00501    337.00501 
Loop time of 61.9132 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.396 ns/day, 17.198 hours/ns, 16.152 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 60.961     | 60.961     | 60.961     |   0.0 | 98.46
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18558    | 0.18558    | 0.18558    |   0.0 |  0.30
Output  | 0.00017556 | 0.00017556 | 0.00017556 |   0.0 |  0.00
Modify  | 0.66414    | 0.66414    | 0.66414    |   0.0 |  1.07
Other   |            | 0.1019     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      577726.0 ave      577726 max      577726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 577726
Ave neighs/atom = 144.43150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.971527993131, Press = 0.501177620949352
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 8.7
  ghost atom cutoff = 8.7
  binsize = 4.35, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 8.7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.481 | 5.481 | 5.481 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -11556.493   -11556.493   -11718.517   -11718.517    313.44694    313.44694    72667.608    72667.608    337.00501    337.00501 
   74000   -11562.596   -11562.596   -11720.708   -11720.708     305.8782     305.8782    72665.052    72665.052    203.21915    203.21915 
Loop time of 61.9906 on 1 procs for 1000 steps with 4000 atoms

Performance: 1.394 ns/day, 17.220 hours/ns, 16.131 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 61.04      | 61.04      | 61.04      |   0.0 | 98.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.18621    | 0.18621    | 0.18621    |   0.0 |  0.30
Output  | 0.00017677 | 0.00017677 | 0.00017677 |   0.0 |  0.00
Modify  | 0.66379    | 0.66379    | 0.66379    |   0.0 |  1.07
Other   |            | 0.1002     |            |       |  0.16

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        8195.00 ave        8195 max        8195 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      578766.0 ave      578766 max      578766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 578766
Ave neighs/atom = 144.69150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
72677.8983965651

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0