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

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

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

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

kim_interactions Cr

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

kim interactions Cr
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_FarkasCaro_2018_FeNiCrCoCu__MO_803527979660_000
pair_coeff * * Cr
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 51.9961

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_803527979660_000#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -8218.4043   -8218.4043   -8288.9838   -8288.9838       273.15       273.15    21829.486    21829.486    3453.4669    3453.4669 
    1000   -8183.4774   -8183.4774   -8254.2606   -8254.2606    273.93829    273.93829    22306.421    22306.421     1897.456     1897.456 
Loop time of 31.3837 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.753 ns/day, 8.718 hours/ns, 31.864 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    | 30.728     | 30.728     | 30.728     |   0.0 | 97.91
Neigh   | 0.096097   | 0.096097   | 0.096097   |   0.0 |  0.31
Comm    | 0.13738    | 0.13738    | 0.13738    |   0.0 |  0.44
Output  | 0.00019601 | 0.00019601 | 0.00019601 |   0.0 |  0.00
Modify  | 0.35775    | 0.35775    | 0.35775    |   0.0 |  1.14
Other   |            | 0.06394    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5483.00 ave        5483 max        5483 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      342026.0 ave      342026 max      342026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 342026
Ave neighs/atom = 171.01300
Neighbor list builds = 2
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -8183.4774   -8183.4774   -8254.2606   -8254.2606    273.93829    273.93829    22306.421    22306.421     1897.456     1897.456 
    2000    -8196.194    -8196.194   -8269.6438   -8269.6438    284.25853    284.25853    22275.435    22275.435   -472.28716   -472.28716 
Loop time of 32.2812 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.676 ns/day, 8.967 hours/ns, 30.978 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.692     | 31.692     | 31.692     |   0.0 | 98.17
Neigh   | 0.047804   | 0.047804   | 0.047804   |   0.0 |  0.15
Comm    | 0.12925    | 0.12925    | 0.12925    |   0.0 |  0.40
Output  | 0.000191   | 0.000191   | 0.000191   |   0.0 |  0.00
Modify  | 0.3484     | 0.3484     | 0.3484     |   0.0 |  1.08
Other   |            | 0.06381    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5479.00 ave        5479 max        5479 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      345622.0 ave      345622 max      345622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 345622
Ave neighs/atom = 172.81100
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000    -8196.194    -8196.194   -8269.6438   -8269.6438    284.25853    284.25853    22275.435    22275.435   -472.28716   -472.28716 
    3000   -8203.4725   -8203.4725   -8273.4916   -8273.4916    270.98141    270.98141    22221.693    22221.693    1326.7797    1326.7797 
Loop time of 32.4043 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.815     | 31.815     | 31.815     |   0.0 | 98.18
Neigh   | 0.047997   | 0.047997   | 0.047997   |   0.0 |  0.15
Comm    | 0.1285     | 0.1285     | 0.1285     |   0.0 |  0.40
Output  | 0.00018903 | 0.00018903 | 0.00018903 |   0.0 |  0.00
Modify  | 0.34812    | 0.34812    | 0.34812    |   0.0 |  1.07
Other   |            | 0.06449    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5495.00 ave        5495 max        5495 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      349090.0 ave      349090 max      349090 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349090
Ave neighs/atom = 174.54500
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8203.4725   -8203.4725   -8273.4916   -8273.4916    270.98141    270.98141    22221.693    22221.693    1326.7797    1326.7797 
    4000   -8209.3822   -8209.3822   -8277.4437   -8277.4437    263.40476    263.40476     22253.48     22253.48   -1424.7894   -1424.7894 
Loop time of 32.8911 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.627 ns/day, 9.136 hours/ns, 30.403 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.341     | 32.341     | 32.341     |   0.0 | 98.33
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12943    | 0.12943    | 0.12943    |   0.0 |  0.39
Output  | 0.00018708 | 0.00018708 | 0.00018708 |   0.0 |  0.00
Modify  | 0.35593    | 0.35593    | 0.35593    |   0.0 |  1.08
Other   |            | 0.06477    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5519.00 ave        5519 max        5519 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350314.0 ave      350314 max      350314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350314
Ave neighs/atom = 175.15700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -8209.3822   -8209.3822   -8277.4437   -8277.4437    263.40476    263.40476     22253.48     22253.48   -1424.7894   -1424.7894 
    5000   -8204.8683   -8204.8683   -8278.4983   -8278.4983    284.95584    284.95584    22238.069    22238.069   -1187.1438   -1187.1438 
Loop time of 33.5102 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.578 ns/day, 9.308 hours/ns, 29.842 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.948     | 32.948     | 32.948     |   0.0 | 98.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13163    | 0.13163    | 0.13163    |   0.0 |  0.39
Output  | 0.00018307 | 0.00018307 | 0.00018307 |   0.0 |  0.00
Modify  | 0.3659     | 0.3659     | 0.3659     |   0.0 |  1.09
Other   |            | 0.06472    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5530.00 ave        5530 max        5530 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350386.0 ave      350386 max      350386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350386
Ave neighs/atom = 175.19300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 275.524792592568, Press = -1379.77920153097
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8204.8683   -8204.8683   -8278.4983   -8278.4983    284.95584    284.95584    22238.069    22238.069   -1187.1438   -1187.1438 
    6000   -8208.2864   -8208.2864   -8277.2408   -8277.2408    266.86084    266.86084    22204.465    22204.465    2376.4916    2376.4916 
Loop time of 33.0564 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.614 ns/day, 9.182 hours/ns, 30.251 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.488     | 32.488     | 32.488     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13004    | 0.13004    | 0.13004    |   0.0 |  0.39
Output  | 0.00015466 | 0.00015466 | 0.00015466 |   0.0 |  0.00
Modify  | 0.37418    | 0.37418    | 0.37418    |   0.0 |  1.13
Other   |            | 0.06444    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5531.00 ave        5531 max        5531 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350300.0 ave      350300 max      350300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350300
Ave neighs/atom = 175.15000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 274.763493090382, Press = 25.7066934867965
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8208.2864   -8208.2864   -8277.2408   -8277.2408    266.86084    266.86084    22204.465    22204.465    2376.4916    2376.4916 
    7000   -8205.4823   -8205.4823   -8276.8187   -8276.8187    276.07919    276.07919    22242.679    22242.679   -970.49149   -970.49149 
Loop time of 34.1867 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.527 ns/day, 9.496 hours/ns, 29.251 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 33.58      | 33.58      | 33.58      |   0.0 | 98.22
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1366     | 0.1366     | 0.1366     |   0.0 |  0.40
Output  | 0.00014635 | 0.00014635 | 0.00014635 |   0.0 |  0.00
Modify  | 0.40396    | 0.40396    | 0.40396    |   0.0 |  1.18
Other   |            | 0.0662     |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5539.00 ave        5539 max        5539 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351264.0 ave      351264 max      351264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351264
Ave neighs/atom = 175.63200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 274.489082968822, Press = -31.2844964801681
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8205.4823   -8205.4823   -8276.8187   -8276.8187    276.07919    276.07919    22242.679    22242.679   -970.49149   -970.49149 
    8000   -8204.3633   -8204.3633   -8276.1572   -8276.1572    277.84982    277.84982    22227.546    22227.546    888.55223    888.55223 
Loop time of 33.7202 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.562 ns/day, 9.367 hours/ns, 29.656 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 33.134     | 33.134     | 33.134     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13339    | 0.13339    | 0.13339    |   0.0 |  0.40
Output  | 0.0001929  | 0.0001929  | 0.0001929  |   0.0 |  0.00
Modify  | 0.387      | 0.387      | 0.387      |   0.0 |  1.15
Other   |            | 0.06515    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5541.00 ave        5541 max        5541 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350538.0 ave      350538 max      350538 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350538
Ave neighs/atom = 175.26900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 274.038802995428, Press = -35.9762835705168
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -8204.3633   -8204.3633   -8276.1572   -8276.1572    277.84982    277.84982    22227.546    22227.546    888.55223    888.55223 
    9000   -8207.4567   -8207.4567   -8277.7925   -8277.7925    272.20677    272.20677    22200.999    22200.999    2285.4076    2285.4076 
Loop time of 32.4513 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.662 ns/day, 9.014 hours/ns, 30.815 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.891     | 31.891     | 31.891     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12824    | 0.12824    | 0.12824    |   0.0 |  0.40
Output  | 0.0001533  | 0.0001533  | 0.0001533  |   0.0 |  0.00
Modify  | 0.36771    | 0.36771    | 0.36771    |   0.0 |  1.13
Other   |            | 0.06383    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5531.00 ave        5531 max        5531 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350718.0 ave      350718 max      350718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350718
Ave neighs/atom = 175.35900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 274.499600893252, Press = 1.97073982568352
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -8207.4567   -8207.4567   -8277.7925   -8277.7925    272.20677    272.20677    22200.999    22200.999    2285.4076    2285.4076 
   10000   -8202.9926   -8202.9926   -8275.9927   -8275.9927    282.51803    282.51803    22258.892    22258.892   -1664.1093   -1664.1093 
Loop time of 33.9549 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.545 ns/day, 9.432 hours/ns, 29.451 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    | 33.367     | 33.367     | 33.367     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13454    | 0.13454    | 0.13454    |   0.0 |  0.40
Output  | 0.00015153 | 0.00015153 | 0.00015153 |   0.0 |  0.00
Modify  | 0.388      | 0.388      | 0.388      |   0.0 |  1.14
Other   |            | 0.06475    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5529.00 ave        5529 max        5529 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351416.0 ave      351416 max      351416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351416
Ave neighs/atom = 175.70800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 274.308504292618, Press = -18.8152112929401
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8202.9926   -8202.9926   -8275.9927   -8275.9927    282.51803    282.51803    22258.892    22258.892   -1664.1093   -1664.1093 
   11000   -8207.1387   -8207.1387   -8278.6539   -8278.6539      276.771      276.771    22209.653    22209.653    922.74082    922.74082 
Loop time of 33.2389 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.599 ns/day, 9.233 hours/ns, 30.085 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.662     | 32.662     | 32.662     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13095    | 0.13095    | 0.13095    |   0.0 |  0.39
Output  | 0.00019701 | 0.00019701 | 0.00019701 |   0.0 |  0.00
Modify  | 0.3813     | 0.3813     | 0.3813     |   0.0 |  1.15
Other   |            | 0.06486    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5505.00 ave        5505 max        5505 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350672.0 ave      350672 max      350672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350672
Ave neighs/atom = 175.33600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 274.574508284696, Press = -9.78975496426979
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8207.1387   -8207.1387   -8278.6539   -8278.6539      276.771      276.771    22209.653    22209.653    922.74082    922.74082 
   12000    -8204.253    -8204.253   -8276.1041   -8276.1041    278.07105    278.07105    22248.429    22248.429   -696.09184   -696.09184 
Loop time of 32.9752 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.620 ns/day, 9.160 hours/ns, 30.326 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.405     | 32.405     | 32.405     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13021    | 0.13021    | 0.13021    |   0.0 |  0.39
Output  | 0.00015658 | 0.00015658 | 0.00015658 |   0.0 |  0.00
Modify  | 0.37556    | 0.37556    | 0.37556    |   0.0 |  1.14
Other   |            | 0.0641     |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5524.00 ave        5524 max        5524 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351346.0 ave      351346 max      351346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351346
Ave neighs/atom = 175.67300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 274.43298612375, Press = -4.984383028546
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000    -8204.253    -8204.253   -8276.1041   -8276.1041    278.07105    278.07105    22248.429    22248.429   -696.09184   -696.09184 
   13000   -8207.5725   -8207.5725   -8277.0314   -8277.0314    268.81301    268.81301     22254.15     22254.15   -2010.5224   -2010.5224 
Loop time of 33.3155 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.593 ns/day, 9.254 hours/ns, 30.016 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.739     | 32.739     | 32.739     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13162    | 0.13162    | 0.13162    |   0.0 |  0.40
Output  | 0.00015479 | 0.00015479 | 0.00015479 |   0.0 |  0.00
Modify  | 0.38021    | 0.38021    | 0.38021    |   0.0 |  1.14
Other   |            | 0.06481    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5538.00 ave        5538 max        5538 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350728.0 ave      350728 max      350728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350728
Ave neighs/atom = 175.36400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 274.272540179076, Press = -8.27932525035285
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8207.5725   -8207.5725   -8277.0314   -8277.0314    268.81301    268.81301     22254.15     22254.15   -2010.5224   -2010.5224 
   14000   -8206.4305   -8206.4305   -8276.4698   -8276.4698    271.05929    271.05929    22228.408    22228.408    296.09891    296.09891 
Loop time of 33.1791 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.604 ns/day, 9.216 hours/ns, 30.139 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.601     | 32.601     | 32.601     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13191    | 0.13191    | 0.13191    |   0.0 |  0.40
Output  | 0.00015637 | 0.00015637 | 0.00015637 |   0.0 |  0.00
Modify  | 0.38147    | 0.38147    | 0.38147    |   0.0 |  1.15
Other   |            | 0.06504    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5536.00 ave        5536 max        5536 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350384.0 ave      350384 max      350384 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350384
Ave neighs/atom = 175.19200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.972327316076, Press = -13.8893834638474
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8206.4305   -8206.4305   -8276.4698   -8276.4698    271.05929    271.05929    22228.408    22228.408    296.09891    296.09891 
   15000   -8209.6813   -8209.6813    -8280.047    -8280.047    272.32284    272.32284    22180.595    22180.595    3142.9414    3142.9414 
Loop time of 33.5789 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.573 ns/day, 9.327 hours/ns, 29.781 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 33         | 33         | 33         |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13116    | 0.13116    | 0.13116    |   0.0 |  0.39
Output  | 0.00015142 | 0.00015142 | 0.00015142 |   0.0 |  0.00
Modify  | 0.38317    | 0.38317    | 0.38317    |   0.0 |  1.14
Other   |            | 0.06477    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5523.00 ave        5523 max        5523 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350902.0 ave      350902 max      350902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350902
Ave neighs/atom = 175.45100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.83951506288, Press = 0.112002327159317
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -8209.6813   -8209.6813    -8280.047    -8280.047    272.32284    272.32284    22180.595    22180.595    3142.9414    3142.9414 
   16000   -8204.6952   -8204.6952   -8278.1301   -8278.1301    284.20047    284.20047    22244.231    22244.231   -1269.4777   -1269.4777 
Loop time of 32.8153 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.633 ns/day, 9.115 hours/ns, 30.474 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.248     | 32.248     | 32.248     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13083    | 0.13083    | 0.13083    |   0.0 |  0.40
Output  | 0.00015423 | 0.00015423 | 0.00015423 |   0.0 |  0.00
Modify  | 0.37196    | 0.37196    | 0.37196    |   0.0 |  1.13
Other   |            | 0.06403    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5542.00 ave        5542 max        5542 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351558.0 ave      351558 max      351558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351558
Ave neighs/atom = 175.77900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.804288491978, Press = -2.50285885443527
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8204.6952   -8204.6952   -8278.1301   -8278.1301    284.20047    284.20047    22244.231    22244.231   -1269.4777   -1269.4777 
   17000   -8208.5403   -8208.5403   -8277.9605   -8277.9605    268.66342    268.66342    22223.586    22223.586    331.46689    331.46689 
Loop time of 33.3255 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.593 ns/day, 9.257 hours/ns, 30.007 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.746     | 32.746     | 32.746     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13112    | 0.13112    | 0.13112    |   0.0 |  0.39
Output  | 0.00020152 | 0.00020152 | 0.00020152 |   0.0 |  0.00
Modify  | 0.38356    | 0.38356    | 0.38356    |   0.0 |  1.15
Other   |            | 0.06434    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5526.00 ave        5526 max        5526 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350822.0 ave      350822 max      350822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350822
Ave neighs/atom = 175.41100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.788468734312, Press = -3.35103971009534
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8208.5403   -8208.5403   -8277.9605   -8277.9605    268.66342    268.66342    22223.586    22223.586    331.46689    331.46689 
   18000   -8204.5871   -8204.5871   -8276.8395   -8276.8395    279.62435    279.62435    22226.549    22226.549    535.74117    535.74117 
Loop time of 33.3387 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.592 ns/day, 9.261 hours/ns, 29.995 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.762     | 32.762     | 32.762     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13127    | 0.13127    | 0.13127    |   0.0 |  0.39
Output  | 0.0001968  | 0.0001968  | 0.0001968  |   0.0 |  0.00
Modify  | 0.38032    | 0.38032    | 0.38032    |   0.0 |  1.14
Other   |            | 0.06448    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5528.00 ave        5528 max        5528 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351166.0 ave      351166 max      351166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351166
Ave neighs/atom = 175.58300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.666910428312, Press = -5.02416032563926
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8204.5871   -8204.5871   -8276.8395   -8276.8395    279.62435    279.62435    22226.549    22226.549    535.74117    535.74117 
   19000   -8206.7417   -8206.7417    -8279.172    -8279.172    280.31296    280.31296    22234.179    22234.179   -780.43323   -780.43323 
Loop time of 33.92 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.547 ns/day, 9.422 hours/ns, 29.481 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 33.333     | 33.333     | 33.333     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13308    | 0.13308    | 0.13308    |   0.0 |  0.39
Output  | 0.00015483 | 0.00015483 | 0.00015483 |   0.0 |  0.00
Modify  | 0.38874    | 0.38874    | 0.38874    |   0.0 |  1.15
Other   |            | 0.0647     |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5538.00 ave        5538 max        5538 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350934.0 ave      350934 max      350934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350934
Ave neighs/atom = 175.46700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.652498925497, Press = 2.77373022589216
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8206.7417   -8206.7417    -8279.172    -8279.172    280.31296    280.31296    22234.179    22234.179   -780.43323   -780.43323 
   20000   -8208.2726   -8208.2726   -8276.3851   -8276.3851    263.60226    263.60226    22239.702    22239.702   -769.45139   -769.45139 
Loop time of 32.9036 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.626 ns/day, 9.140 hours/ns, 30.392 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.336     | 32.336     | 32.336     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13043    | 0.13043    | 0.13043    |   0.0 |  0.40
Output  | 0.00015681 | 0.00015681 | 0.00015681 |   0.0 |  0.00
Modify  | 0.37277    | 0.37277    | 0.37277    |   0.0 |  1.13
Other   |            | 0.06385    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5532.00 ave        5532 max        5532 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350834.0 ave      350834 max      350834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350834
Ave neighs/atom = 175.41700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.788750091024, Press = -7.62829236053699
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8208.2726   -8208.2726   -8276.3851   -8276.3851    263.60226    263.60226    22239.702    22239.702   -769.45139   -769.45139 
   21000   -8204.2625   -8204.2625   -8276.8128   -8276.8128    280.77704    280.77704    22215.172    22215.172    1446.4217    1446.4217 
Loop time of 32.8393 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.631 ns/day, 9.122 hours/ns, 30.451 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.276     | 32.276     | 32.276     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12924    | 0.12924    | 0.12924    |   0.0 |  0.39
Output  | 0.00019633 | 0.00019633 | 0.00019633 |   0.0 |  0.00
Modify  | 0.36955    | 0.36955    | 0.36955    |   0.0 |  1.13
Other   |            | 0.06434    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5540.00 ave        5540 max        5540 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350672.0 ave      350672 max      350672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350672
Ave neighs/atom = 175.33600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.825317648061, Press = -1.90305513347878
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8204.2625   -8204.2625   -8276.8128   -8276.8128    280.77704    280.77704    22215.172    22215.172    1446.4217    1446.4217 
   22000   -8208.2765   -8208.2765   -8278.2186   -8278.2186     270.6831     270.6831    22209.411    22209.411    1351.0123    1351.0123 
Loop time of 33.8885 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.550 ns/day, 9.413 hours/ns, 29.509 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 33.3       | 33.3       | 33.3       |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13349    | 0.13349    | 0.13349    |   0.0 |  0.39
Output  | 0.00015546 | 0.00015546 | 0.00015546 |   0.0 |  0.00
Modify  | 0.39003    | 0.39003    | 0.39003    |   0.0 |  1.15
Other   |            | 0.06475    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5536.00 ave        5536 max        5536 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351086.0 ave      351086 max      351086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351086
Ave neighs/atom = 175.54300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.906614444486, Press = -4.06326840319108
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8208.2765   -8208.2765   -8278.2186   -8278.2186     270.6831     270.6831    22209.411    22209.411    1351.0123    1351.0123 
   23000   -8205.7395   -8205.7395   -8277.0002   -8277.0002    275.78608    275.78608    22231.091    22231.091    94.946067    94.946067 
Loop time of 33.1084 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.610 ns/day, 9.197 hours/ns, 30.204 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.533     | 32.533     | 32.533     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13087    | 0.13087    | 0.13087    |   0.0 |  0.40
Output  | 0.0001997  | 0.0001997  | 0.0001997  |   0.0 |  0.00
Modify  | 0.37918    | 0.37918    | 0.37918    |   0.0 |  1.15
Other   |            | 0.06529    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5534.00 ave        5534 max        5534 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351466.0 ave      351466 max      351466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351466
Ave neighs/atom = 175.73300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.772019799957, Press = -0.990254739686308
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8205.7395   -8205.7395   -8277.0002   -8277.0002    275.78608    275.78608    22231.091    22231.091    94.946067    94.946067 
   24000   -8208.1208   -8208.1208   -8275.6757   -8275.6757    261.44459    261.44459    22249.116    22249.116    -744.0013    -744.0013 
Loop time of 33.096 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.611 ns/day, 9.193 hours/ns, 30.215 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.521     | 32.521     | 32.521     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13081    | 0.13081    | 0.13081    |   0.0 |  0.40
Output  | 0.00015445 | 0.00015445 | 0.00015445 |   0.0 |  0.00
Modify  | 0.37865    | 0.37865    | 0.37865    |   0.0 |  1.14
Other   |            | 0.06537    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5550.00 ave        5550 max        5550 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350834.0 ave      350834 max      350834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350834
Ave neighs/atom = 175.41700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.696862308625, Press = -3.65378677675836
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8208.1208   -8208.1208   -8275.6757   -8275.6757    261.44459    261.44459    22249.116    22249.116    -744.0013    -744.0013 
   25000   -8205.0797   -8205.0797   -8277.2685   -8277.2685    279.37797    279.37797    22245.893    22245.893   -1248.5264   -1248.5264 
Loop time of 32.87 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.629 ns/day, 9.131 hours/ns, 30.423 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.307     | 32.307     | 32.307     |   0.0 | 98.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12846    | 0.12846    | 0.12846    |   0.0 |  0.39
Output  | 0.00015794 | 0.00015794 | 0.00015794 |   0.0 |  0.00
Modify  | 0.37056    | 0.37056    | 0.37056    |   0.0 |  1.13
Other   |            | 0.06374    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5526.00 ave        5526 max        5526 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350760.0 ave      350760 max      350760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350760
Ave neighs/atom = 175.38000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.694862985666, Press = -3.11236791903928
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8205.0797   -8205.0797   -8277.2685   -8277.2685    279.37797    279.37797    22245.893    22245.893   -1248.5264   -1248.5264 
   26000   -8207.4905   -8207.4905   -8276.5858   -8276.5858    267.40612    267.40612    22235.798    22235.798   -119.88199   -119.88199 
Loop time of 33.2464 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.599 ns/day, 9.235 hours/ns, 30.078 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.67      | 32.67      | 32.67      |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13153    | 0.13153    | 0.13153    |   0.0 |  0.40
Output  | 0.00042679 | 0.00042679 | 0.00042679 |   0.0 |  0.00
Modify  | 0.38048    | 0.38048    | 0.38048    |   0.0 |  1.14
Other   |            | 0.06446    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5517.00 ave        5517 max        5517 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350748.0 ave      350748 max      350748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350748
Ave neighs/atom = 175.37400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.781504977835, Press = -4.78266062083131
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -8207.4905   -8207.4905   -8276.5858   -8276.5858    267.40612    267.40612    22235.798    22235.798   -119.88199   -119.88199 
   27000   -8202.7811   -8202.7811   -8276.0865   -8276.0865    283.69968    283.69968    22207.357    22207.357    2486.2449    2486.2449 
Loop time of 33.1954 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.603 ns/day, 9.221 hours/ns, 30.125 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.625     | 32.625     | 32.625     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13024    | 0.13024    | 0.13024    |   0.0 |  0.39
Output  | 0.00015357 | 0.00015357 | 0.00015357 |   0.0 |  0.00
Modify  | 0.37555    | 0.37555    | 0.37555    |   0.0 |  1.13
Other   |            | 0.06462    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5518.00 ave        5518 max        5518 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350950.0 ave      350950 max      350950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350950
Ave neighs/atom = 175.47500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.847271038639, Press = -1.08587083022705
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8202.7811   -8202.7811   -8276.0865   -8276.0865    283.69968    283.69968    22207.357    22207.357    2486.2449    2486.2449 
   28000   -8208.6721   -8208.6721   -8278.0545   -8278.0545    268.51678    268.51678    22235.052    22235.052   -683.46203   -683.46203 
Loop time of 32.6627 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.645 ns/day, 9.073 hours/ns, 30.616 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.101     | 32.101     | 32.101     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12779    | 0.12779    | 0.12779    |   0.0 |  0.39
Output  | 0.00015661 | 0.00015661 | 0.00015661 |   0.0 |  0.00
Modify  | 0.36942    | 0.36942    | 0.36942    |   0.0 |  1.13
Other   |            | 0.0647     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5534.00 ave        5534 max        5534 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351414.0 ave      351414 max      351414 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351414
Ave neighs/atom = 175.70700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.863272843666, Press = -0.133460851255184
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8208.6721   -8208.6721   -8278.0545   -8278.0545    268.51678    268.51678    22235.052    22235.052   -683.46203   -683.46203 
   29000   -8207.9466   -8207.9466   -8278.2318   -8278.2318    272.01094    272.01094    22241.854    22241.854   -1254.7289   -1254.7289 
Loop time of 33.868 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.551 ns/day, 9.408 hours/ns, 29.526 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 33.276     | 33.276     | 33.276     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13375    | 0.13375    | 0.13375    |   0.0 |  0.39
Output  | 0.0001998  | 0.0001998  | 0.0001998  |   0.0 |  0.00
Modify  | 0.39306    | 0.39306    | 0.39306    |   0.0 |  1.16
Other   |            | 0.06519    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5528.00 ave        5528 max        5528 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350822.0 ave      350822 max      350822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350822
Ave neighs/atom = 175.41100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.847176331607, Press = -3.9205064227691
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8207.9466   -8207.9466   -8278.2318   -8278.2318    272.01094    272.01094    22241.854    22241.854   -1254.7289   -1254.7289 
   30000   -8205.2503   -8205.2503   -8277.6324   -8277.6324    280.12624    280.12624      22191.8      22191.8     3104.212     3104.212 
Loop time of 32.334 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.672 ns/day, 8.982 hours/ns, 30.927 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.775     | 31.775     | 31.775     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12772    | 0.12772    | 0.12772    |   0.0 |  0.40
Output  | 0.00015546 | 0.00015546 | 0.00015546 |   0.0 |  0.00
Modify  | 0.36666    | 0.36666    | 0.36666    |   0.0 |  1.13
Other   |            | 0.06401    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5536.00 ave        5536 max        5536 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350586.0 ave      350586 max      350586 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350586
Ave neighs/atom = 175.29300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.816709217049, Press = -3.34605619286755
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8205.2503   -8205.2503   -8277.6324   -8277.6324    280.12624    280.12624      22191.8      22191.8     3104.212     3104.212 
   31000   -8206.9796   -8206.9796   -8277.5634   -8277.5634    273.16639    273.16639    22222.947    22222.947    643.18563    643.18563 
Loop time of 33.2503 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.598 ns/day, 9.236 hours/ns, 30.075 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.666     | 32.666     | 32.666     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1327     | 0.1327     | 0.1327     |   0.0 |  0.40
Output  | 0.00015587 | 0.00015587 | 0.00015587 |   0.0 |  0.00
Modify  | 0.38551    | 0.38551    | 0.38551    |   0.0 |  1.16
Other   |            | 0.06585    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5539.00 ave        5539 max        5539 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351646.0 ave      351646 max      351646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351646
Ave neighs/atom = 175.82300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.812941703441, Press = 1.58792724018682
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8206.9796   -8206.9796   -8277.5634   -8277.5634    273.16639    273.16639    22222.947    22222.947    643.18563    643.18563 
   32000   -8208.3186   -8208.3186   -8279.8174   -8279.8174    276.70772    276.70772    22236.709    22236.709   -1505.0065   -1505.0065 
Loop time of 32.8851 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.627 ns/day, 9.135 hours/ns, 30.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    | 32.316     | 32.316     | 32.316     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13079    | 0.13079    | 0.13079    |   0.0 |  0.40
Output  | 0.00015204 | 0.00015204 | 0.00015204 |   0.0 |  0.00
Modify  | 0.37271    | 0.37271    | 0.37271    |   0.0 |  1.13
Other   |            | 0.06544    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5524.00 ave        5524 max        5524 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351040.0 ave      351040 max      351040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351040
Ave neighs/atom = 175.52000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.798062096013, Press = -3.33049024526206
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -8208.3186   -8208.3186   -8279.8174   -8279.8174    276.70772    276.70772    22236.709    22236.709   -1505.0065   -1505.0065 
   33000   -8206.4694   -8206.4694   -8277.1324   -8277.1324    273.47322    273.47322    22203.125    22203.125    2433.2873    2433.2873 
Loop time of 32.873 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.303     | 32.303     | 32.303     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12892    | 0.12892    | 0.12892    |   0.0 |  0.39
Output  | 0.00017119 | 0.00017119 | 0.00017119 |   0.0 |  0.00
Modify  | 0.3757     | 0.3757     | 0.3757     |   0.0 |  1.14
Other   |            | 0.06472    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5513.00 ave        5513 max        5513 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350666.0 ave      350666 max      350666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350666
Ave neighs/atom = 175.33300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.717446973945, Press = -1.86816341543685
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -8206.4694   -8206.4694   -8277.1324   -8277.1324    273.47322    273.47322    22203.125    22203.125    2433.2873    2433.2873 
   34000   -8207.7523   -8207.7523   -8278.5767   -8278.5767    274.09753    274.09753     22215.97     22215.97     835.8107     835.8107 
Loop time of 33.2394 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.599 ns/day, 9.233 hours/ns, 30.085 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.666     | 32.666     | 32.666     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13022    | 0.13022    | 0.13022    |   0.0 |  0.39
Output  | 0.0001993  | 0.0001993  | 0.0001993  |   0.0 |  0.00
Modify  | 0.37774    | 0.37774    | 0.37774    |   0.0 |  1.14
Other   |            | 0.06509    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5520.00 ave        5520 max        5520 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351330.0 ave      351330 max      351330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351330
Ave neighs/atom = 175.66500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.668376733478, Press = 0.0205578545399314
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -8207.7523   -8207.7523   -8278.5767   -8278.5767    274.09753    274.09753     22215.97     22215.97     835.8107     835.8107 
   35000   -8206.1433   -8206.1433   -8276.1844   -8276.1844    271.06635    271.06635     22265.14     22265.14   -2289.2787   -2289.2787 
Loop time of 32.6396 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.647 ns/day, 9.067 hours/ns, 30.638 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.076     | 32.076     | 32.076     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12808    | 0.12808    | 0.12808    |   0.0 |  0.39
Output  | 0.00015628 | 0.00015628 | 0.00015628 |   0.0 |  0.00
Modify  | 0.37011    | 0.37011    | 0.37011    |   0.0 |  1.13
Other   |            | 0.06484    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5537.00 ave        5537 max        5537 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351198.0 ave      351198 max      351198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351198
Ave neighs/atom = 175.59900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.599455351255, Press = -2.89857227048288
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8206.1433   -8206.1433   -8276.1844   -8276.1844    271.06635    271.06635     22265.14     22265.14   -2289.2787   -2289.2787 
   36000   -8208.0752   -8208.0752   -8279.3237   -8279.3237    275.73917    275.73917    22184.783    22184.783    3195.5431    3195.5431 
Loop time of 33.441 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.584 ns/day, 9.289 hours/ns, 29.903 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.866     | 32.866     | 32.866     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13057    | 0.13057    | 0.13057    |   0.0 |  0.39
Output  | 0.00019693 | 0.00019693 | 0.00019693 |   0.0 |  0.00
Modify  | 0.37913    | 0.37913    | 0.37913    |   0.0 |  1.13
Other   |            | 0.06497    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5521.00 ave        5521 max        5521 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350346.0 ave      350346 max      350346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350346
Ave neighs/atom = 175.17300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.56123691941, Press = -4.12537357850041
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -8208.0752   -8208.0752   -8279.3237   -8279.3237    275.73917    275.73917    22184.783    22184.783    3195.5431    3195.5431 
   37000   -8207.1142   -8207.1142   -8277.9143   -8277.9143    274.00335    274.00335    22217.958    22217.958    772.34408    772.34408 
Loop time of 32.9551 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.622 ns/day, 9.154 hours/ns, 30.344 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.385     | 32.385     | 32.385     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13001    | 0.13001    | 0.13001    |   0.0 |  0.39
Output  | 0.00015044 | 0.00015044 | 0.00015044 |   0.0 |  0.00
Modify  | 0.37495    | 0.37495    | 0.37495    |   0.0 |  1.14
Other   |            | 0.06523    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5546.00 ave        5546 max        5546 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351664.0 ave      351664 max      351664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351664
Ave neighs/atom = 175.83200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.471309514493, Press = 0.447383544979469
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -8207.1142   -8207.1142   -8277.9143   -8277.9143    274.00335    274.00335    22217.958    22217.958    772.34408    772.34408 
   38000   -8207.5396   -8207.5396   -8278.7522   -8278.7522    275.60045    275.60045    22229.504    22229.504    21.424706    21.424706 
Loop time of 33.3551 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.590 ns/day, 9.265 hours/ns, 29.980 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.778     | 32.778     | 32.778     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13113    | 0.13113    | 0.13113    |   0.0 |  0.39
Output  | 0.00015328 | 0.00015328 | 0.00015328 |   0.0 |  0.00
Modify  | 0.38151    | 0.38151    | 0.38151    |   0.0 |  1.14
Other   |            | 0.06409    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5521.00 ave        5521 max        5521 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351348.0 ave      351348 max      351348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351348
Ave neighs/atom = 175.67400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.465673570915, Press = -2.16691438019518
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -8207.5396   -8207.5396   -8278.7522   -8278.7522    275.60045    275.60045    22229.504    22229.504    21.424706    21.424706 
   39000   -8205.4127   -8205.4127   -8276.6216   -8276.6216    275.58591    275.58591    22210.394    22210.394    1739.6178    1739.6178 
Loop time of 32.8527 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.630 ns/day, 9.126 hours/ns, 30.439 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.279     | 32.279     | 32.279     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13149    | 0.13149    | 0.13149    |   0.0 |  0.40
Output  | 0.0001622  | 0.0001622  | 0.0001622  |   0.0 |  0.00
Modify  | 0.37724    | 0.37724    | 0.37724    |   0.0 |  1.15
Other   |            | 0.06458    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5527.00 ave        5527 max        5527 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350836.0 ave      350836 max      350836 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350836
Ave neighs/atom = 175.41800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.485399485361, Press = -0.981484254128905
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8205.4127   -8205.4127   -8276.6216   -8276.6216    275.58591    275.58591    22210.394    22210.394    1739.6178    1739.6178 
   40000   -8209.4327   -8209.4327   -8278.0295   -8278.0295    265.47686    265.47686    22228.061    22228.061   -154.65013   -154.65013 
Loop time of 32.8695 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.629 ns/day, 9.130 hours/ns, 30.423 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.3       | 32.3       | 32.3       |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13024    | 0.13024    | 0.13024    |   0.0 |  0.40
Output  | 0.00015557 | 0.00015557 | 0.00015557 |   0.0 |  0.00
Modify  | 0.37426    | 0.37426    | 0.37426    |   0.0 |  1.14
Other   |            | 0.06442    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5522.00 ave        5522 max        5522 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351254.0 ave      351254 max      351254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351254
Ave neighs/atom = 175.62700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.53299103584, Press = -1.4346569636282
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -8209.4327   -8209.4327   -8278.0295   -8278.0295    265.47686    265.47686    22228.061    22228.061   -154.65013   -154.65013 
   41000   -8206.7418   -8206.7418   -8277.9124   -8277.9124     275.4376     275.4376    22188.746    22188.746    2980.7636    2980.7636 
Loop time of 33.2001 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.602 ns/day, 9.222 hours/ns, 30.120 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.625     | 32.625     | 32.625     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13128    | 0.13128    | 0.13128    |   0.0 |  0.40
Output  | 0.00015395 | 0.00015395 | 0.00015395 |   0.0 |  0.00
Modify  | 0.3779     | 0.3779     | 0.3779     |   0.0 |  1.14
Other   |            | 0.06538    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5538.00 ave        5538 max        5538 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351108.0 ave      351108 max      351108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351108
Ave neighs/atom = 175.55400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.521057738864, Press = -1.81144771102825
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -8206.7418   -8206.7418   -8277.9124   -8277.9124     275.4376     275.4376    22188.746    22188.746    2980.7636    2980.7636 
   42000   -8208.5488   -8208.5488   -8278.7887   -8278.7887    271.83586    271.83586    22225.417    22225.417    444.46637    444.46637 
Loop time of 33.4731 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.581 ns/day, 9.298 hours/ns, 29.875 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.896     | 32.896     | 32.896     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1311     | 0.1311     | 0.1311     |   0.0 |  0.39
Output  | 0.00016366 | 0.00016366 | 0.00016366 |   0.0 |  0.00
Modify  | 0.38048    | 0.38048    | 0.38048    |   0.0 |  1.14
Other   |            | 0.06517    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5527.00 ave        5527 max        5527 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351740.0 ave      351740 max      351740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351740
Ave neighs/atom = 175.87000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.521925547243, Press = 0.150274389166277
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -8208.5488   -8208.5488   -8278.7887   -8278.7887    271.83586    271.83586    22225.417    22225.417    444.46637    444.46637 
   43000   -8207.7248   -8207.7248   -8278.1158   -8278.1158    272.42039    272.42039    22274.412    22274.412   -4362.1614   -4362.1614 
Loop time of 32.8685 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.629 ns/day, 9.130 hours/ns, 30.424 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.295     | 32.295     | 32.295     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12995    | 0.12995    | 0.12995    |   0.0 |  0.40
Output  | 0.00019433 | 0.00019433 | 0.00019433 |   0.0 |  0.00
Modify  | 0.37807    | 0.37807    | 0.37807    |   0.0 |  1.15
Other   |            | 0.06524    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5525.00 ave        5525 max        5525 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351114.0 ave      351114 max      351114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351114
Ave neighs/atom = 175.55700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.526358009044, Press = -1.12196388097984
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8207.7248   -8207.7248   -8278.1158   -8278.1158    272.42039    272.42039    22274.412    22274.412   -4362.1614   -4362.1614 
   44000   -8209.1676   -8209.1676   -8279.0255   -8279.0255    270.35749    270.35749    22233.567    22233.567   -440.75869   -440.75869 
Loop time of 32.3141 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.674 ns/day, 8.976 hours/ns, 30.946 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.757     | 31.757     | 31.757     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12767    | 0.12767    | 0.12767    |   0.0 |  0.40
Output  | 0.00015474 | 0.00015474 | 0.00015474 |   0.0 |  0.00
Modify  | 0.36495    | 0.36495    | 0.36495    |   0.0 |  1.13
Other   |            | 0.0643     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5528.00 ave        5528 max        5528 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      349858.0 ave      349858 max      349858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349858
Ave neighs/atom = 174.92900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.55444109902, Press = -3.06675978950998
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -8209.1676   -8209.1676   -8279.0255   -8279.0255    270.35749    270.35749    22233.567    22233.567   -440.75869   -440.75869 
   45000   -8204.7725   -8204.7725   -8275.7894   -8275.7894    274.84273    274.84273    22221.727    22221.727    1356.7743    1356.7743 
Loop time of 32.5757 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.652 ns/day, 9.049 hours/ns, 30.698 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.019     | 32.019     | 32.019     |   0.0 | 98.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12647    | 0.12647    | 0.12647    |   0.0 |  0.39
Output  | 0.00015271 | 0.00015271 | 0.00015271 |   0.0 |  0.00
Modify  | 0.36591    | 0.36591    | 0.36591    |   0.0 |  1.12
Other   |            | 0.0639     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5523.00 ave        5523 max        5523 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350850.0 ave      350850 max      350850 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350850
Ave neighs/atom = 175.42500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.56114261808, Press = -0.63405749817146
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -8204.7725   -8204.7725   -8275.7894   -8275.7894    274.84273    274.84273    22221.727    22221.727    1356.7743    1356.7743 
   46000   -8207.2441   -8207.2441   -8278.3341   -8278.3341    275.12554    275.12554     22239.92     22239.92   -1259.3605   -1259.3605 
Loop time of 33.3588 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.590 ns/day, 9.266 hours/ns, 29.977 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.779     | 32.779     | 32.779     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13143    | 0.13143    | 0.13143    |   0.0 |  0.39
Output  | 0.00015295 | 0.00015295 | 0.00015295 |   0.0 |  0.00
Modify  | 0.38251    | 0.38251    | 0.38251    |   0.0 |  1.15
Other   |            | 0.06541    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5527.00 ave        5527 max        5527 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351036.0 ave      351036 max      351036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351036
Ave neighs/atom = 175.51800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.510900648322, Press = -1.79273035514294
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -8207.2441   -8207.2441   -8278.3341   -8278.3341    275.12554    275.12554     22239.92     22239.92   -1259.3605   -1259.3605 
   47000   -8205.4764   -8205.4764   -8278.4624   -8278.4624    282.46326    282.46326    22230.211    22230.211   -262.96091   -262.96091 
Loop time of 32.9999 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.618 ns/day, 9.167 hours/ns, 30.303 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.431     | 32.431     | 32.431     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12932    | 0.12932    | 0.12932    |   0.0 |  0.39
Output  | 0.00023998 | 0.00023998 | 0.00023998 |   0.0 |  0.00
Modify  | 0.37416    | 0.37416    | 0.37416    |   0.0 |  1.13
Other   |            | 0.06512    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5522.00 ave        5522 max        5522 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350864.0 ave      350864 max      350864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350864
Ave neighs/atom = 175.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 = 273.532475625012, Press = -2.6712081557196
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -8205.4764   -8205.4764   -8278.4624   -8278.4624    282.46326    282.46326    22230.211    22230.211   -262.96091   -262.96091 
   48000   -8207.3408   -8207.3408   -8277.8946   -8277.8946    273.05055    273.05055    22217.373    22217.373    1142.1166    1142.1166 
Loop time of 32.4866 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.660 ns/day, 9.024 hours/ns, 30.782 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    | 31.923     | 31.923     | 31.923     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12897    | 0.12897    | 0.12897    |   0.0 |  0.40
Output  | 0.0001545  | 0.0001545  | 0.0001545  |   0.0 |  0.00
Modify  | 0.36972    | 0.36972    | 0.36972    |   0.0 |  1.14
Other   |            | 0.06491    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5523.00 ave        5523 max        5523 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350972.0 ave      350972 max      350972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350972
Ave neighs/atom = 175.48600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.558499545593, Press = -1.74036824182256
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -8207.3408   -8207.3408   -8277.8946   -8277.8946    273.05055    273.05055    22217.373    22217.373    1142.1166    1142.1166 
   49000   -8206.9238   -8206.9238   -8277.8218   -8277.8218    274.38261    274.38261    22191.822    22191.822    3387.0018    3387.0018 
Loop time of 33.7918 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.557 ns/day, 9.387 hours/ns, 29.593 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 33.199     | 33.199     | 33.199     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13383    | 0.13383    | 0.13383    |   0.0 |  0.40
Output  | 0.00015323 | 0.00015323 | 0.00015323 |   0.0 |  0.00
Modify  | 0.39281    | 0.39281    | 0.39281    |   0.0 |  1.16
Other   |            | 0.0661     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5541.00 ave        5541 max        5541 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351170.0 ave      351170 max      351170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351170
Ave neighs/atom = 175.58500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.566992535433, Press = 1.22051034909476
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -8206.9238   -8206.9238   -8277.8218   -8277.8218    274.38261    274.38261    22191.822    22191.822    3387.0018    3387.0018 
   50000   -8210.6144   -8210.6144   -8276.0832   -8276.0832    253.37121    253.37121    22265.579    22265.579   -2784.2838   -2784.2838 
Loop time of 32.948 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.622 ns/day, 9.152 hours/ns, 30.351 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.372     | 32.372     | 32.372     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13062    | 0.13062    | 0.13062    |   0.0 |  0.40
Output  | 0.00015546 | 0.00015546 | 0.00015546 |   0.0 |  0.00
Modify  | 0.37993    | 0.37993    | 0.37993    |   0.0 |  1.15
Other   |            | 0.06477    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5527.00 ave        5527 max        5527 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351478.0 ave      351478 max      351478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351478
Ave neighs/atom = 175.73900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.504038700165, Press = -0.451419939488258
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -8210.6144   -8210.6144   -8276.0832   -8276.0832    253.37121    253.37121    22265.579    22265.579   -2784.2838   -2784.2838 
   51000   -8207.3579   -8207.3579   -8278.9856   -8278.9856     277.2068     277.2068    22225.184    22225.184    216.15821    216.15821 
Loop time of 32.5433 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.655 ns/day, 9.040 hours/ns, 30.728 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.978     | 31.978     | 31.978     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12987    | 0.12987    | 0.12987    |   0.0 |  0.40
Output  | 0.00014574 | 0.00014574 | 0.00014574 |   0.0 |  0.00
Modify  | 0.37088    | 0.37088    | 0.37088    |   0.0 |  1.14
Other   |            | 0.06413    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5526.00 ave        5526 max        5526 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350454.0 ave      350454 max      350454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350454
Ave neighs/atom = 175.22700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.51196618611, Press = -1.86235984426552
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -8207.3579   -8207.3579   -8278.9856   -8278.9856     277.2068     277.2068    22225.184    22225.184    216.15821    216.15821 
   52000   -8203.5702   -8203.5702   -8276.0018   -8276.0018    280.31766    280.31766    22233.584    22233.584    367.93712    367.93712 
Loop time of 32.6889 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.123     | 32.123     | 32.123     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12902    | 0.12902    | 0.12902    |   0.0 |  0.39
Output  | 0.0002017  | 0.0002017  | 0.0002017  |   0.0 |  0.00
Modify  | 0.37256    | 0.37256    | 0.37256    |   0.0 |  1.14
Other   |            | 0.06412    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5527.00 ave        5527 max        5527 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350868.0 ave      350868 max      350868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350868
Ave neighs/atom = 175.43400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.532080649907, Press = -0.714664829528053
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -8203.5702   -8203.5702   -8276.0018   -8276.0018    280.31766    280.31766    22233.584    22233.584    367.93712    367.93712 
   53000   -8207.9504   -8207.9504    -8278.778    -8278.778    274.11015    274.11015    22237.045    22237.045   -1041.4487   -1041.4487 
Loop time of 33.4609 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.582 ns/day, 9.295 hours/ns, 29.886 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.881     | 32.881     | 32.881     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1323     | 0.1323     | 0.1323     |   0.0 |  0.40
Output  | 0.00015183 | 0.00015183 | 0.00015183 |   0.0 |  0.00
Modify  | 0.38297    | 0.38297    | 0.38297    |   0.0 |  1.14
Other   |            | 0.06459    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5532.00 ave        5532 max        5532 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350978.0 ave      350978 max      350978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350978
Ave neighs/atom = 175.48900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.554911984035, Press = 0.272705233827848
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -8207.9504   -8207.9504    -8278.778    -8278.778    274.11015    274.11015    22237.045    22237.045   -1041.4487   -1041.4487 
   54000   -8208.9896   -8208.9896   -8279.5751   -8279.5751    273.17331    273.17331     22254.98     22254.98   -2442.1551   -2442.1551 
Loop time of 33.5463 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.576 ns/day, 9.318 hours/ns, 29.810 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.956     | 32.956     | 32.956     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13389    | 0.13389    | 0.13389    |   0.0 |  0.40
Output  | 0.00015532 | 0.00015532 | 0.00015532 |   0.0 |  0.00
Modify  | 0.391      | 0.391      | 0.391      |   0.0 |  1.17
Other   |            | 0.06554    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5501.00 ave        5501 max        5501 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350524.0 ave      350524 max      350524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350524
Ave neighs/atom = 175.26200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.582055840365, Press = -2.43338130107455
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -8208.9896   -8208.9896   -8279.5751   -8279.5751    273.17331    273.17331     22254.98     22254.98   -2442.1551   -2442.1551 
   55000   -8205.4584   -8205.4584   -8278.2059   -8278.2059    281.54034    281.54034    22193.578    22193.578     2690.397     2690.397 
Loop time of 32.9173 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.625 ns/day, 9.144 hours/ns, 30.379 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.344     | 32.344     | 32.344     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13031    | 0.13031    | 0.13031    |   0.0 |  0.40
Output  | 0.00015393 | 0.00015393 | 0.00015393 |   0.0 |  0.00
Modify  | 0.37766    | 0.37766    | 0.37766    |   0.0 |  1.15
Other   |            | 0.06485    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5518.00 ave        5518 max        5518 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350486.0 ave      350486 max      350486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350486
Ave neighs/atom = 175.24300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.576881821588, Press = -2.16293654775072
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -8205.4584   -8205.4584   -8278.2059   -8278.2059    281.54034    281.54034    22193.578    22193.578     2690.397     2690.397 
   56000    -8208.769    -8208.769   -8279.9126   -8279.9126    275.33276    275.33276    22225.041    22225.041    -227.6096    -227.6096 
Loop time of 33.5319 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.577 ns/day, 9.314 hours/ns, 29.822 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.951     | 32.951     | 32.951     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13219    | 0.13219    | 0.13219    |   0.0 |  0.39
Output  | 0.00015275 | 0.00015275 | 0.00015275 |   0.0 |  0.00
Modify  | 0.38274    | 0.38274    | 0.38274    |   0.0 |  1.14
Other   |            | 0.06548    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5539.00 ave        5539 max        5539 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351620.0 ave      351620 max      351620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351620
Ave neighs/atom = 175.81000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.542623905413, Press = -0.559468018471971
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000    -8208.769    -8208.769   -8279.9126   -8279.9126    275.33276    275.33276    22225.041    22225.041    -227.6096    -227.6096 
   57000   -8207.3862   -8207.3862   -8278.2498   -8278.2498    274.24959    274.24959      22229.6      22229.6   -303.56156   -303.56156 
Loop time of 32.3128 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.674 ns/day, 8.976 hours/ns, 30.947 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.751     | 31.751     | 31.751     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12811    | 0.12811    | 0.12811    |   0.0 |  0.40
Output  | 0.00019755 | 0.00019755 | 0.00019755 |   0.0 |  0.00
Modify  | 0.36851    | 0.36851    | 0.36851    |   0.0 |  1.14
Other   |            | 0.06485    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5519.00 ave        5519 max        5519 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350974.0 ave      350974 max      350974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350974
Ave neighs/atom = 175.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 = 273.499142360973, Press = -1.14867575264211
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -8207.3862   -8207.3862   -8278.2498   -8278.2498    274.24959    274.24959      22229.6      22229.6   -303.56156   -303.56156 
   58000   -8205.8678   -8205.8678   -8277.7674   -8277.7674    278.25865    278.25865    22232.333    22232.333   -374.70821   -374.70821 
Loop time of 32.9165 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.625 ns/day, 9.143 hours/ns, 30.380 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.342     | 32.342     | 32.342     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13142    | 0.13142    | 0.13142    |   0.0 |  0.40
Output  | 0.00015689 | 0.00015689 | 0.00015689 |   0.0 |  0.00
Modify  | 0.37844    | 0.37844    | 0.37844    |   0.0 |  1.15
Other   |            | 0.06482    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5535.00 ave        5535 max        5535 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350702.0 ave      350702 max      350702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350702
Ave neighs/atom = 175.35100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.533454377545, Press = -1.00857721090226
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -8205.8678   -8205.8678   -8277.7674   -8277.7674    278.25865    278.25865    22232.333    22232.333   -374.70821   -374.70821 
   59000   -8205.4475   -8205.4475   -8278.3869   -8278.3869    282.28267    282.28267    22232.496    22232.496    -408.6103    -408.6103 
Loop time of 32.7244 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.640 ns/day, 9.090 hours/ns, 30.558 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.157     | 32.157     | 32.157     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13066    | 0.13066    | 0.13066    |   0.0 |  0.40
Output  | 0.00015384 | 0.00015384 | 0.00015384 |   0.0 |  0.00
Modify  | 0.37195    | 0.37195    | 0.37195    |   0.0 |  1.14
Other   |            | 0.06446    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5537.00 ave        5537 max        5537 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351322.0 ave      351322 max      351322 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351322
Ave neighs/atom = 175.66100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.548924309916, Press = -1.86490412548238
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -8205.4475   -8205.4475   -8278.3869   -8278.3869    282.28267    282.28267    22232.496    22232.496    -408.6103    -408.6103 
   60000   -8208.2385   -8208.2385   -8278.3261   -8278.3261    271.24609    271.24609     22209.52     22209.52    1424.3686    1424.3686 
Loop time of 32.8252 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.632 ns/day, 9.118 hours/ns, 30.464 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.254     | 32.254     | 32.254     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13063    | 0.13063    | 0.13063    |   0.0 |  0.40
Output  | 0.00015315 | 0.00015315 | 0.00015315 |   0.0 |  0.00
Modify  | 0.37518    | 0.37518    | 0.37518    |   0.0 |  1.14
Other   |            | 0.0649     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5537.00 ave        5537 max        5537 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351034.0 ave      351034 max      351034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351034
Ave neighs/atom = 175.51700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.576636377527, Press = 0.646592937924713
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -8208.2385   -8208.2385   -8278.3261   -8278.3261    271.24609    271.24609     22209.52     22209.52    1424.3686    1424.3686 
   61000   -8206.5413   -8206.5413    -8277.723    -8277.723    275.48071    275.48071    22251.854    22251.854   -1890.3053   -1890.3053 
Loop time of 32.8451 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.631 ns/day, 9.124 hours/ns, 30.446 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.269     | 32.269     | 32.269     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13137    | 0.13137    | 0.13137    |   0.0 |  0.40
Output  | 0.00015437 | 0.00015437 | 0.00015437 |   0.0 |  0.00
Modify  | 0.37903    | 0.37903    | 0.37903    |   0.0 |  1.15
Other   |            | 0.06538    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5534.00 ave        5534 max        5534 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351378.0 ave      351378 max      351378 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351378
Ave neighs/atom = 175.68900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.572334417641, Press = -0.225580513174912
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -8206.5413   -8206.5413    -8277.723    -8277.723    275.48071    275.48071    22251.854    22251.854   -1890.3053   -1890.3053 
   62000   -8209.6389   -8209.6389   -8279.6747   -8279.6747    271.04603    271.04603    22244.456    22244.456   -1864.5508   -1864.5508 
Loop time of 32.9677 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.394     | 32.394     | 32.394     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1306     | 0.1306     | 0.1306     |   0.0 |  0.40
Output  | 0.0001558  | 0.0001558  | 0.0001558  |   0.0 |  0.00
Modify  | 0.37769    | 0.37769    | 0.37769    |   0.0 |  1.15
Other   |            | 0.06475    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5536.00 ave        5536 max        5536 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350528.0 ave      350528 max      350528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350528
Ave neighs/atom = 175.26400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.556613526472, Press = -1.13373719830447
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -8209.6389   -8209.6389   -8279.6747   -8279.6747    271.04603    271.04603    22244.456    22244.456   -1864.5508   -1864.5508 
   63000   -8203.0282   -8203.0282   -8277.7953   -8277.7953    289.35659    289.35659    22231.084    22231.084   -117.53246   -117.53246 
Loop time of 33.1042 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.610 ns/day, 9.196 hours/ns, 30.208 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    | 32.525     | 32.525     | 32.525     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13126    | 0.13126    | 0.13126    |   0.0 |  0.40
Output  | 0.00015541 | 0.00015541 | 0.00015541 |   0.0 |  0.00
Modify  | 0.38191    | 0.38191    | 0.38191    |   0.0 |  1.15
Other   |            | 0.06566    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5520.00 ave        5520 max        5520 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350444.0 ave      350444 max      350444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350444
Ave neighs/atom = 175.22200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.576996193084, Press = -0.997780524781365
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -8203.0282   -8203.0282   -8277.7953   -8277.7953    289.35659    289.35659    22231.084    22231.084   -117.53246   -117.53246 
   64000   -8207.2501   -8207.2501   -8277.7127   -8277.7127    272.69769    272.69769    22246.675    22246.675   -1219.5169   -1219.5169 
Loop time of 32.2683 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.678 ns/day, 8.963 hours/ns, 30.990 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.71      | 31.71      | 31.71      |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12825    | 0.12825    | 0.12825    |   0.0 |  0.40
Output  | 0.00015373 | 0.00015373 | 0.00015373 |   0.0 |  0.00
Modify  | 0.36573    | 0.36573    | 0.36573    |   0.0 |  1.13
Other   |            | 0.06392    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5533.00 ave        5533 max        5533 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351424.0 ave      351424 max      351424 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351424
Ave neighs/atom = 175.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 = 273.5829321472, Press = -0.959584277962501
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -8207.2501   -8207.2501   -8277.7127   -8277.7127    272.69769    272.69769    22246.675    22246.675   -1219.5169   -1219.5169 
   65000   -8205.9405   -8205.9405   -8276.8523   -8276.8523    274.43591    274.43591    22212.733    22212.733    1644.5654    1644.5654 
Loop time of 32.7281 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.640 ns/day, 9.091 hours/ns, 30.555 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.162     | 32.162     | 32.162     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12905    | 0.12905    | 0.12905    |   0.0 |  0.39
Output  | 0.00019949 | 0.00019949 | 0.00019949 |   0.0 |  0.00
Modify  | 0.37207    | 0.37207    | 0.37207    |   0.0 |  1.14
Other   |            | 0.06472    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5520.00 ave        5520 max        5520 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350612.0 ave      350612 max      350612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350612
Ave neighs/atom = 175.30600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.619548043732, Press = -0.246499129931554
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -8205.9405   -8205.9405   -8276.8523   -8276.8523    274.43591    274.43591    22212.733    22212.733    1644.5654    1644.5654 
   66000   -8204.7004   -8204.7004   -8276.7081   -8276.7081    278.67724    278.67724    22220.221    22220.221    1051.3299    1051.3299 
Loop time of 32.7548 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.638 ns/day, 9.099 hours/ns, 30.530 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.188     | 32.188     | 32.188     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1297     | 0.1297     | 0.1297     |   0.0 |  0.40
Output  | 0.00019463 | 0.00019463 | 0.00019463 |   0.0 |  0.00
Modify  | 0.3724     | 0.3724     | 0.3724     |   0.0 |  1.14
Other   |            | 0.065      |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5526.00 ave        5526 max        5526 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351276.0 ave      351276 max      351276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351276
Ave neighs/atom = 175.63800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.620506595683, Press = 0.208555741028769
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -8204.7004   -8204.7004   -8276.7081   -8276.7081    278.67724    278.67724    22220.221    22220.221    1051.3299    1051.3299 
   67000   -8208.9455   -8208.9455   -8279.2962   -8279.2962    272.26426    272.26426    22250.502    22250.502   -2135.9318   -2135.9318 
Loop time of 32.2576 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.678 ns/day, 8.960 hours/ns, 31.000 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.701     | 31.701     | 31.701     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12781    | 0.12781    | 0.12781    |   0.0 |  0.40
Output  | 0.00015597 | 0.00015597 | 0.00015597 |   0.0 |  0.00
Modify  | 0.36389    | 0.36389    | 0.36389    |   0.0 |  1.13
Other   |            | 0.06498    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5525.00 ave        5525 max        5525 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351036.0 ave      351036 max      351036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351036
Ave neighs/atom = 175.51800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.630604715026, Press = -0.591684538136213
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -8208.9455   -8208.9455   -8279.2962   -8279.2962    272.26426    272.26426    22250.502    22250.502   -2135.9318   -2135.9318 
   68000   -8206.7928   -8206.7928   -8277.9857   -8277.9857    275.52389    275.52389    22226.777    22226.777    470.33122    470.33122 
Loop time of 32.1304 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.689 ns/day, 8.925 hours/ns, 31.123 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.572     | 31.572     | 31.572     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12834    | 0.12834    | 0.12834    |   0.0 |  0.40
Output  | 0.00015597 | 0.00015597 | 0.00015597 |   0.0 |  0.00
Modify  | 0.36537    | 0.36537    | 0.36537    |   0.0 |  1.14
Other   |            | 0.06441    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5530.00 ave        5530 max        5530 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350454.0 ave      350454 max      350454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350454
Ave neighs/atom = 175.22700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.610961203834, Press = -1.10647846634069
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -8206.7928   -8206.7928   -8277.9857   -8277.9857    275.52389    275.52389    22226.777    22226.777    470.33122    470.33122 
   69000    -8206.053    -8206.053   -8276.9244   -8276.9244    274.27951    274.27951    22213.678    22213.678    1288.7693    1288.7693 
Loop time of 32.1257 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.689 ns/day, 8.924 hours/ns, 31.128 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.566     | 31.566     | 31.566     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1284     | 0.1284     | 0.1284     |   0.0 |  0.40
Output  | 0.00015726 | 0.00015726 | 0.00015726 |   0.0 |  0.00
Modify  | 0.36753    | 0.36753    | 0.36753    |   0.0 |  1.14
Other   |            | 0.06411    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5507.00 ave        5507 max        5507 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351026.0 ave      351026 max      351026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351026
Ave neighs/atom = 175.51300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.644761475492, Press = -1.35675492148301
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000    -8206.053    -8206.053   -8276.9244   -8276.9244    274.27951    274.27951    22213.678    22213.678    1288.7693    1288.7693 
   70000   -8205.0836   -8205.0836   -8276.3792   -8276.3792    275.92136    275.92136    22216.536    22216.536     1772.028     1772.028 
Loop time of 32.4649 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.661 ns/day, 9.018 hours/ns, 30.802 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.902     | 31.902     | 31.902     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12834    | 0.12834    | 0.12834    |   0.0 |  0.40
Output  | 0.00015821 | 0.00015821 | 0.00015821 |   0.0 |  0.00
Modify  | 0.36905    | 0.36905    | 0.36905    |   0.0 |  1.14
Other   |            | 0.06509    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5511.00 ave        5511 max        5511 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351346.0 ave      351346 max      351346 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351346
Ave neighs/atom = 175.67300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.65234260079, Press = -0.323486330594655
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -8205.0836   -8205.0836   -8276.3792   -8276.3792    275.92136    275.92136    22216.536    22216.536     1772.028     1772.028 
   71000   -8210.3663   -8210.3663   -8279.1825   -8279.1825    266.32572    266.32572    22218.238    22218.238   -224.53645   -224.53645 
Loop time of 32.8696 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.629 ns/day, 9.130 hours/ns, 30.423 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.299     | 32.299     | 32.299     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12992    | 0.12992    | 0.12992    |   0.0 |  0.40
Output  | 0.00015347 | 0.00015347 | 0.00015347 |   0.0 |  0.00
Modify  | 0.37585    | 0.37585    | 0.37585    |   0.0 |  1.14
Other   |            | 0.06502    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5546.00 ave        5546 max        5546 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351218.0 ave      351218 max      351218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351218
Ave neighs/atom = 175.60900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.636974788747, Press = -0.438140771754444
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -8210.3663   -8210.3663   -8279.1825   -8279.1825    266.32572    266.32572    22218.238    22218.238   -224.53645   -224.53645 
   72000   -8206.0477   -8206.0477   -8277.3427   -8277.3427    275.91906    275.91906    22233.435    22233.435   -59.525358   -59.525358 
Loop time of 33.4134 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.586 ns/day, 9.282 hours/ns, 29.928 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.834     | 32.834     | 32.834     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13068    | 0.13068    | 0.13068    |   0.0 |  0.39
Output  | 0.00015553 | 0.00015553 | 0.00015553 |   0.0 |  0.00
Modify  | 0.38351    | 0.38351    | 0.38351    |   0.0 |  1.15
Other   |            | 0.06519    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5537.00 ave        5537 max        5537 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350960.0 ave      350960 max      350960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350960
Ave neighs/atom = 175.48000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.594716702031, Press = -1.10206315672469
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -8206.0477   -8206.0477   -8277.3427   -8277.3427    275.91906    275.91906    22233.435    22233.435   -59.525358   -59.525358 
   73000   -8210.1696   -8210.1696   -8279.3323   -8279.3323    267.66693    267.66693    22212.763    22212.763    420.81995    420.81995 
Loop time of 32.6885 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.121     | 32.121     | 32.121     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12874    | 0.12874    | 0.12874    |   0.0 |  0.39
Output  | 0.00015365 | 0.00015365 | 0.00015365 |   0.0 |  0.00
Modify  | 0.3737     | 0.3737     | 0.3737     |   0.0 |  1.14
Other   |            | 0.06511    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5517.00 ave        5517 max        5517 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350786.0 ave      350786 max      350786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350786
Ave neighs/atom = 175.39300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.561550487706, Press = -0.440449683263935
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -8210.1696   -8210.1696   -8279.3323   -8279.3323    267.66693    267.66693    22212.763    22212.763    420.81995    420.81995 
   74000   -8207.3214   -8207.3214   -8277.8022   -8277.8022    272.76803    272.76803    22223.647    22223.647    467.00079    467.00079 
Loop time of 33.2797 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.596 ns/day, 9.244 hours/ns, 30.048 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.703     | 32.703     | 32.703     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13078    | 0.13078    | 0.13078    |   0.0 |  0.39
Output  | 0.00042105 | 0.00042105 | 0.00042105 |   0.0 |  0.00
Modify  | 0.38033    | 0.38033    | 0.38033    |   0.0 |  1.14
Other   |            | 0.06481    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5532.00 ave        5532 max        5532 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351186.0 ave      351186 max      351186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351186
Ave neighs/atom = 175.59300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.566966225586, Press = -1.91978124593969
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -8207.3214   -8207.3214   -8277.8022   -8277.8022    272.76803    272.76803    22223.647    22223.647    467.00079    467.00079 
   75000   -8205.6259   -8205.6259   -8276.9408   -8276.9408    275.99622    275.99622    22202.611    22202.611    3026.7434    3026.7434 
Loop time of 33.1891 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.603 ns/day, 9.219 hours/ns, 30.130 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.617     | 32.617     | 32.617     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13065    | 0.13065    | 0.13065    |   0.0 |  0.39
Output  | 0.00015319 | 0.00015319 | 0.00015319 |   0.0 |  0.00
Modify  | 0.37653    | 0.37653    | 0.37653    |   0.0 |  1.13
Other   |            | 0.0648     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5536.00 ave        5536 max        5536 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350980.0 ave      350980 max      350980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350980
Ave neighs/atom = 175.49000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.580710520263, Press = -0.360297076955383
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -8205.6259   -8205.6259   -8276.9408   -8276.9408    275.99622    275.99622    22202.611    22202.611    3026.7434    3026.7434 
   76000    -8211.385    -8211.385   -8279.7918   -8279.7918    264.74137    264.74137    22232.091    22232.091   -1358.1181   -1358.1181 
Loop time of 32.3343 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.672 ns/day, 8.982 hours/ns, 30.927 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.772     | 31.772     | 31.772     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12845    | 0.12845    | 0.12845    |   0.0 |  0.40
Output  | 0.00015438 | 0.00015438 | 0.00015438 |   0.0 |  0.00
Modify  | 0.36931    | 0.36931    | 0.36931    |   0.0 |  1.14
Other   |            | 0.06453    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5524.00 ave        5524 max        5524 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351546.0 ave      351546 max      351546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351546
Ave neighs/atom = 175.77300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.572670731508, Press = -0.0112957661712872
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000    -8211.385    -8211.385   -8279.7918   -8279.7918    264.74137    264.74137    22232.091    22232.091   -1358.1181   -1358.1181 
   77000   -8206.3554   -8206.3554   -8275.6426   -8275.6426    268.14871    268.14871    22242.274    22242.274   -161.44671   -161.44671 
Loop time of 32.1272 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.689 ns/day, 8.924 hours/ns, 31.126 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.567     | 31.567     | 31.567     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12721    | 0.12721    | 0.12721    |   0.0 |  0.40
Output  | 0.00015423 | 0.00015423 | 0.00015423 |   0.0 |  0.00
Modify  | 0.36831    | 0.36831    | 0.36831    |   0.0 |  1.15
Other   |            | 0.0646     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5531.00 ave        5531 max        5531 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350678.0 ave      350678 max      350678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350678
Ave neighs/atom = 175.33900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.549222381269, Press = -1.228471461679
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000   -8206.3554   -8206.3554   -8275.6426   -8275.6426    268.14871    268.14871    22242.274    22242.274   -161.44671   -161.44671 
   78000   -8207.5438   -8207.5438    -8277.811    -8277.811    271.94155    271.94155    22247.908    22247.908   -1499.0436   -1499.0436 
Loop time of 33.1615 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.605 ns/day, 9.212 hours/ns, 30.155 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.583     | 32.583     | 32.583     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13128    | 0.13128    | 0.13128    |   0.0 |  0.40
Output  | 0.00015482 | 0.00015482 | 0.00015482 |   0.0 |  0.00
Modify  | 0.38151    | 0.38151    | 0.38151    |   0.0 |  1.15
Other   |            | 0.06567    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5513.00 ave        5513 max        5513 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350964.0 ave      350964 max      350964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350964
Ave neighs/atom = 175.48200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.55841799945, Press = -1.12411285027222
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -8207.5438   -8207.5438    -8277.811    -8277.811    271.94155    271.94155    22247.908    22247.908   -1499.0436   -1499.0436 
   79000   -8207.1885   -8207.1885   -8278.1747   -8278.1747    274.72371    274.72371    22213.225    22213.225    1350.0739    1350.0739 
Loop time of 32.9453 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.368     | 32.368     | 32.368     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13026    | 0.13026    | 0.13026    |   0.0 |  0.40
Output  | 0.00015294 | 0.00015294 | 0.00015294 |   0.0 |  0.00
Modify  | 0.38178    | 0.38178    | 0.38178    |   0.0 |  1.16
Other   |            | 0.06543    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5517.00 ave        5517 max        5517 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350412.0 ave      350412 max      350412 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350412
Ave neighs/atom = 175.20600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.540463671114, Press = -1.27130462756838
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -8207.1885   -8207.1885   -8278.1747   -8278.1747    274.72371    274.72371    22213.225    22213.225    1350.0739    1350.0739 
   80000    -8204.685    -8204.685    -8277.731    -8277.731    282.69558    282.69558    22239.895    22239.895   -728.55278   -728.55278 
Loop time of 32.8401 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.631 ns/day, 9.122 hours/ns, 30.451 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.268     | 32.268     | 32.268     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1296     | 0.1296     | 0.1296     |   0.0 |  0.39
Output  | 0.00015587 | 0.00015587 | 0.00015587 |   0.0 |  0.00
Modify  | 0.37775    | 0.37775    | 0.37775    |   0.0 |  1.15
Other   |            | 0.06473    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5538.00 ave        5538 max        5538 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351268.0 ave      351268 max      351268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351268
Ave neighs/atom = 175.63400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.5365073432, Press = 0.0981561487819703
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000    -8204.685    -8204.685    -8277.731    -8277.731    282.69558    282.69558    22239.895    22239.895   -728.55278   -728.55278 
   81000   -8208.6253   -8208.6253   -8278.4643   -8278.4643    270.28409    270.28409    22259.055    22259.055   -3167.8587   -3167.8587 
Loop time of 32.3008 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.738     | 31.738     | 31.738     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12778    | 0.12778    | 0.12778    |   0.0 |  0.40
Output  | 0.00015418 | 0.00015418 | 0.00015418 |   0.0 |  0.00
Modify  | 0.36956    | 0.36956    | 0.36956    |   0.0 |  1.14
Other   |            | 0.06578    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5528.00 ave        5528 max        5528 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350704.0 ave      350704 max      350704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350704
Ave neighs/atom = 175.35200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.544912791545, Press = -1.50351330677291
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -8208.6253   -8208.6253   -8278.4643   -8278.4643    270.28409    270.28409    22259.055    22259.055   -3167.8587   -3167.8587 
   82000    -8203.317    -8203.317   -8277.7718   -8277.7718    288.14769    288.14769    22203.521    22203.521     2703.687     2703.687 
Loop time of 32.4533 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.662 ns/day, 9.015 hours/ns, 30.814 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    | 31.89      | 31.89      | 31.89      |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1292     | 0.1292     | 0.1292     |   0.0 |  0.40
Output  | 0.00015781 | 0.00015781 | 0.00015781 |   0.0 |  0.00
Modify  | 0.36887    | 0.36887    | 0.36887    |   0.0 |  1.14
Other   |            | 0.06466    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5535.00 ave        5535 max        5535 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350580.0 ave      350580 max      350580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350580
Ave neighs/atom = 175.29000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.563327081847, Press = -0.982630059739358
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000    -8203.317    -8203.317   -8277.7718   -8277.7718    288.14769    288.14769    22203.521    22203.521     2703.687     2703.687 
   83000   -8207.7102   -8207.7102   -8279.0889   -8279.0889    276.24281    276.24281    22224.631    22224.631   -244.88778   -244.88778 
Loop time of 33.1854 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.604 ns/day, 9.218 hours/ns, 30.134 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.605     | 32.605     | 32.605     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1318     | 0.1318     | 0.1318     |   0.0 |  0.40
Output  | 0.00020204 | 0.00020204 | 0.00020204 |   0.0 |  0.00
Modify  | 0.38293    | 0.38293    | 0.38293    |   0.0 |  1.15
Other   |            | 0.06517    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5532.00 ave        5532 max        5532 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351516.0 ave      351516 max      351516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351516
Ave neighs/atom = 175.75800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.581424246283, Press = -0.105414788753621
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -8207.7102   -8207.7102   -8279.0889   -8279.0889    276.24281    276.24281    22224.631    22224.631   -244.88778   -244.88778 
   84000   -8201.2365   -8201.2365   -8275.7353   -8275.7353    288.31814    288.31814    22216.784    22216.784    1804.9744    1804.9744 
Loop time of 32.2676 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.678 ns/day, 8.963 hours/ns, 30.991 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.704     | 31.704     | 31.704     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1284     | 0.1284     | 0.1284     |   0.0 |  0.40
Output  | 0.00015911 | 0.00015911 | 0.00015911 |   0.0 |  0.00
Modify  | 0.37042    | 0.37042    | 0.37042    |   0.0 |  1.15
Other   |            | 0.06465    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5540.00 ave        5540 max        5540 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350796.0 ave      350796 max      350796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350796
Ave neighs/atom = 175.39800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.600298785011, Press = 0.34620992121529
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -8201.2365   -8201.2365   -8275.7353   -8275.7353    288.31814    288.31814    22216.784    22216.784    1804.9744    1804.9744 
   85000      -8207.4      -8207.4    -8277.713    -8277.713    272.11877    272.11877    22242.625    22242.625   -1489.0374   -1489.0374 
Loop time of 33.6035 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.571 ns/day, 9.334 hours/ns, 29.759 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    | 33.011     | 33.011     | 33.011     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13356    | 0.13356    | 0.13356    |   0.0 |  0.40
Output  | 0.00019175 | 0.00019175 | 0.00019175 |   0.0 |  0.00
Modify  | 0.39301    | 0.39301    | 0.39301    |   0.0 |  1.17
Other   |            | 0.06589    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5520.00 ave        5520 max        5520 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351168.0 ave      351168 max      351168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351168
Ave neighs/atom = 175.58400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.619921483605, Press = -0.60465396553845
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000      -8207.4      -8207.4    -8277.713    -8277.713    272.11877    272.11877    22242.625    22242.625   -1489.0374   -1489.0374 
   86000   -8205.4007   -8205.4007   -8276.9966   -8276.9966    277.08354    277.08354    22215.659    22215.659    1143.6647    1143.6647 
Loop time of 32.7537 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.638 ns/day, 9.098 hours/ns, 30.531 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.188     | 32.188     | 32.188     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12868    | 0.12868    | 0.12868    |   0.0 |  0.39
Output  | 0.00019767 | 0.00019767 | 0.00019767 |   0.0 |  0.00
Modify  | 0.37172    | 0.37172    | 0.37172    |   0.0 |  1.13
Other   |            | 0.06477    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5534.00 ave        5534 max        5534 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350574.0 ave      350574 max      350574 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350574
Ave neighs/atom = 175.28700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.614138912719, Press = -0.682381716361538
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -8205.4007   -8205.4007   -8276.9966   -8276.9966    277.08354    277.08354    22215.659    22215.659    1143.6647    1143.6647 
   87000   -8207.4832   -8207.4832   -8277.0058   -8277.0058    269.05961    269.05961    22251.573    22251.573   -1541.0641   -1541.0641 
Loop time of 32.9312 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.624 ns/day, 9.148 hours/ns, 30.366 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.355     | 32.355     | 32.355     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13159    | 0.13159    | 0.13159    |   0.0 |  0.40
Output  | 0.00015265 | 0.00015265 | 0.00015265 |   0.0 |  0.00
Modify  | 0.37882    | 0.37882    | 0.37882    |   0.0 |  1.15
Other   |            | 0.06527    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5527.00 ave        5527 max        5527 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350986.0 ave      350986 max      350986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350986
Ave neighs/atom = 175.49300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.593601710553, Press = -0.442518749991572
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -8207.4832   -8207.4832   -8277.0058   -8277.0058    269.05961    269.05961    22251.573    22251.573   -1541.0641   -1541.0641 
   88000   -8209.0124   -8209.0124   -8277.5168   -8277.5168    265.11939    265.11939     22250.51     22250.51   -1458.2116   -1458.2116 
Loop time of 32.3533 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.671 ns/day, 8.987 hours/ns, 30.909 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.793     | 31.793     | 31.793     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12753    | 0.12753    | 0.12753    |   0.0 |  0.39
Output  | 0.00019512 | 0.00019512 | 0.00019512 |   0.0 |  0.00
Modify  | 0.36785    | 0.36785    | 0.36785    |   0.0 |  1.14
Other   |            | 0.06445    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5526.00 ave        5526 max        5526 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350514.0 ave      350514 max      350514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350514
Ave neighs/atom = 175.25700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.593839494153, Press = -1.08582886379554
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000   -8209.0124   -8209.0124   -8277.5168   -8277.5168    265.11939    265.11939     22250.51     22250.51   -1458.2116   -1458.2116 
   89000   -8207.8073   -8207.8073   -8277.9305   -8277.9305    271.38413    271.38413    22218.047    22218.047    903.07498    903.07498 
Loop time of 32.1202 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.690 ns/day, 8.922 hours/ns, 31.133 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.565     | 31.565     | 31.565     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12674    | 0.12674    | 0.12674    |   0.0 |  0.39
Output  | 0.00019814 | 0.00019814 | 0.00019814 |   0.0 |  0.00
Modify  | 0.36457    | 0.36457    | 0.36457    |   0.0 |  1.14
Other   |            | 0.06387    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5520.00 ave        5520 max        5520 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350632.0 ave      350632 max      350632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350632
Ave neighs/atom = 175.31600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.582448269734, Press = -0.649857363068059
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -8207.8073   -8207.8073   -8277.9305   -8277.9305    271.38413    271.38413    22218.047    22218.047    903.07498    903.07498 
   90000   -8208.0622   -8208.0622   -8279.6746   -8279.6746    277.14741    277.14741    22223.748    22223.748   -359.08461   -359.08461 
Loop time of 32.3558 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.670 ns/day, 8.988 hours/ns, 30.906 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.794     | 31.794     | 31.794     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12844    | 0.12844    | 0.12844    |   0.0 |  0.40
Output  | 0.000157   | 0.000157   | 0.000157   |   0.0 |  0.00
Modify  | 0.3682     | 0.3682     | 0.3682     |   0.0 |  1.14
Other   |            | 0.06492    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5524.00 ave        5524 max        5524 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350940.0 ave      350940 max      350940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350940
Ave neighs/atom = 175.47000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.543615429721, Press = -0.611402225906457
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -8208.0622   -8208.0622   -8279.6746   -8279.6746    277.14741    277.14741    22223.748    22223.748   -359.08461   -359.08461 
   91000   -8207.3449   -8207.3449   -8277.2248   -8277.2248    270.44222    270.44222    22209.853    22209.853    1269.6281    1269.6281 
Loop time of 33.1414 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.607 ns/day, 9.206 hours/ns, 30.174 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.561     | 32.561     | 32.561     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13175    | 0.13175    | 0.13175    |   0.0 |  0.40
Output  | 0.00015113 | 0.00015113 | 0.00015113 |   0.0 |  0.00
Modify  | 0.38303    | 0.38303    | 0.38303    |   0.0 |  1.16
Other   |            | 0.06566    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5526.00 ave        5526 max        5526 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351206.0 ave      351206 max      351206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351206
Ave neighs/atom = 175.60300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.52319109439, Press = -0.663698258039752
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000   -8207.3449   -8207.3449   -8277.2248   -8277.2248    270.44222    270.44222    22209.853    22209.853    1269.6281    1269.6281 
   92000   -8207.7832   -8207.7832   -8277.8348   -8277.8348    271.10707    271.10707    22187.954    22187.954    3329.1763    3329.1763 
Loop time of 32.8102 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.633 ns/day, 9.114 hours/ns, 30.478 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.239     | 32.239     | 32.239     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13023    | 0.13023    | 0.13023    |   0.0 |  0.40
Output  | 0.00015544 | 0.00015544 | 0.00015544 |   0.0 |  0.00
Modify  | 0.3761     | 0.3761     | 0.3761     |   0.0 |  1.15
Other   |            | 0.06508    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5509.00 ave        5509 max        5509 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351478.0 ave      351478 max      351478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351478
Ave neighs/atom = 175.73900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.495545738276, Press = -0.8019679205811
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000   -8207.7832   -8207.7832   -8277.8348   -8277.8348    271.10707    271.10707    22187.954    22187.954    3329.1763    3329.1763 
   93000   -8206.1621   -8206.1621    -8277.464    -8277.464    275.94602    275.94602    22239.704    22239.704   -603.58178   -603.58178 
Loop time of 32.7536 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.638 ns/day, 9.098 hours/ns, 30.531 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.181     | 32.181     | 32.181     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13097    | 0.13097    | 0.13097    |   0.0 |  0.40
Output  | 0.00015232 | 0.00015232 | 0.00015232 |   0.0 |  0.00
Modify  | 0.37682    | 0.37682    | 0.37682    |   0.0 |  1.15
Other   |            | 0.06508    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5519.00 ave        5519 max        5519 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351810.0 ave      351810 max      351810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351810
Ave neighs/atom = 175.90500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.505685221739, Press = -0.185241795632991
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000   -8206.1621   -8206.1621    -8277.464    -8277.464    275.94602    275.94602    22239.704    22239.704   -603.58178   -603.58178 
   94000    -8207.671    -8207.671   -8279.3575   -8279.3575    277.43402    277.43402    22248.607    22248.607   -2139.2035   -2139.2035 
Loop time of 32.0959 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.692 ns/day, 8.916 hours/ns, 31.157 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.537     | 31.537     | 31.537     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1283     | 0.1283     | 0.1283     |   0.0 |  0.40
Output  | 0.0001549  | 0.0001549  | 0.0001549  |   0.0 |  0.00
Modify  | 0.36572    | 0.36572    | 0.36572    |   0.0 |  1.14
Other   |            | 0.06431    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5532.00 ave        5532 max        5532 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350790.0 ave      350790 max      350790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350790
Ave neighs/atom = 175.39500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.490433621203, Press = -1.53427968201125
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000    -8207.671    -8207.671   -8279.3575   -8279.3575    277.43402    277.43402    22248.607    22248.607   -2139.2035   -2139.2035 
   95000   -8210.3254   -8210.3254   -8279.7675   -8279.7675    268.74826    268.74826    22172.611    22172.611    3978.8809    3978.8809 
Loop time of 32.9903 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.619 ns/day, 9.164 hours/ns, 30.312 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.415     | 32.415     | 32.415     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13077    | 0.13077    | 0.13077    |   0.0 |  0.40
Output  | 0.00015725 | 0.00015725 | 0.00015725 |   0.0 |  0.00
Modify  | 0.37844    | 0.37844    | 0.37844    |   0.0 |  1.15
Other   |            | 0.0655     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5526.00 ave        5526 max        5526 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350710.0 ave      350710 max      350710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350710
Ave neighs/atom = 175.35500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.483959314744, Press = -0.852768178724607
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000   -8210.3254   -8210.3254   -8279.7675   -8279.7675    268.74826    268.74826    22172.611    22172.611    3978.8809    3978.8809 
   96000   -8205.4113   -8205.4113    -8277.153    -8277.153    277.64753    277.64753    22240.164    22240.164   -571.47756   -571.47756 
Loop time of 34.2437 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.523 ns/day, 9.512 hours/ns, 29.202 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 33.649     | 33.649     | 33.649     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1354     | 0.1354     | 0.1354     |   0.0 |  0.40
Output  | 0.0001669  | 0.0001669  | 0.0001669  |   0.0 |  0.00
Modify  | 0.39458    | 0.39458    | 0.39458    |   0.0 |  1.15
Other   |            | 0.06491    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5515.00 ave        5515 max        5515 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      352112.0 ave      352112 max      352112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 352112
Ave neighs/atom = 176.05600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.468078704877, Press = 0.459660545978013
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000   -8205.4113   -8205.4113    -8277.153    -8277.153    277.64753    277.64753    22240.164    22240.164   -571.47756   -571.47756 
   97000   -8207.9299   -8207.9299   -8278.4096   -8278.4096    272.76361    272.76361     22256.52     22256.52   -2421.7337   -2421.7337 
Loop time of 32.2701 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.677 ns/day, 8.964 hours/ns, 30.988 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.71      | 31.71      | 31.71      |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12786    | 0.12786    | 0.12786    |   0.0 |  0.40
Output  | 0.00014931 | 0.00014931 | 0.00014931 |   0.0 |  0.00
Modify  | 0.36794    | 0.36794    | 0.36794    |   0.0 |  1.14
Other   |            | 0.06462    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5526.00 ave        5526 max        5526 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350702.0 ave      350702 max      350702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350702
Ave neighs/atom = 175.35100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.443184025406, Press = -1.3343151455208
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   97000   -8207.9299   -8207.9299   -8278.4096   -8278.4096    272.76361    272.76361     22256.52     22256.52   -2421.7337   -2421.7337 
   98000   -8206.7182   -8206.7182    -8277.401    -8277.401    273.54987    273.54987    22221.242    22221.242    758.28024    758.28024 
Loop time of 32.3822 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.668 ns/day, 8.995 hours/ns, 30.881 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.816     | 31.816     | 31.816     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12902    | 0.12902    | 0.12902    |   0.0 |  0.40
Output  | 0.00015301 | 0.00015301 | 0.00015301 |   0.0 |  0.00
Modify  | 0.37225    | 0.37225    | 0.37225    |   0.0 |  1.15
Other   |            | 0.0651     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5529.00 ave        5529 max        5529 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350484.0 ave      350484 max      350484 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350484
Ave neighs/atom = 175.24200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.41251280755, Press = -0.743083049953021
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   98000   -8206.7182   -8206.7182    -8277.401    -8277.401    273.54987    273.54987    22221.242    22221.242    758.28024    758.28024 
   99000   -8209.3439   -8209.3439   -8277.8703   -8277.8703    265.20434    265.20434     22244.26     22244.26   -801.33461   -801.33461 
Loop time of 32.8652 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.629 ns/day, 9.129 hours/ns, 30.427 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.296     | 32.296     | 32.296     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12947    | 0.12947    | 0.12947    |   0.0 |  0.39
Output  | 0.00015551 | 0.00015551 | 0.00015551 |   0.0 |  0.00
Modify  | 0.37513    | 0.37513    | 0.37513    |   0.0 |  1.14
Other   |            | 0.06484    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5530.00 ave        5530 max        5530 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350936.0 ave      350936 max      350936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350936
Ave neighs/atom = 175.46800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.398655518254, Press = -0.659170003232804
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   99000   -8209.3439   -8209.3439   -8277.8703   -8277.8703    265.20434    265.20434     22244.26     22244.26   -801.33461   -801.33461 
  100000   -8207.4067   -8207.4067   -8277.0842   -8277.0842    269.65918    269.65918    22239.144    22239.144   -937.98832   -937.98832 
Loop time of 33.0232 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.616 ns/day, 9.173 hours/ns, 30.282 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.452     | 32.452     | 32.452     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12973    | 0.12973    | 0.12973    |   0.0 |  0.39
Output  | 0.00020111 | 0.00020111 | 0.00020111 |   0.0 |  0.00
Modify  | 0.37695    | 0.37695    | 0.37695    |   0.0 |  1.14
Other   |            | 0.06406    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5518.00 ave        5518 max        5518 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350924.0 ave      350924 max      350924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350924
Ave neighs/atom = 175.46200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.413563462954, Press = -0.23843043263533
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  100000   -8207.4067   -8207.4067   -8277.0842   -8277.0842    269.65918    269.65918    22239.144    22239.144   -937.98832   -937.98832 
  101000   -8205.5066   -8205.5066   -8275.9441   -8275.9441    272.60037    272.60037    22261.182    22261.182   -1545.8115   -1545.8115 
Loop time of 33.0313 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.616 ns/day, 9.175 hours/ns, 30.274 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.45      | 32.45      | 32.45      |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13212    | 0.13212    | 0.13212    |   0.0 |  0.40
Output  | 0.00019825 | 0.00019825 | 0.00019825 |   0.0 |  0.00
Modify  | 0.38375    | 0.38375    | 0.38375    |   0.0 |  1.16
Other   |            | 0.06487    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5518.00 ave        5518 max        5518 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350562.0 ave      350562 max      350562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350562
Ave neighs/atom = 175.28100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.42533141505, Press = -0.498640644807615
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  101000   -8205.5066   -8205.5066   -8275.9441   -8275.9441    272.60037    272.60037    22261.182    22261.182   -1545.8115   -1545.8115 
  102000   -8208.2442   -8208.2442   -8277.9783   -8277.9783    269.87832    269.87832    22201.092    22201.092    1971.2302    1971.2302 
Loop time of 32.4051 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.843     | 31.843     | 31.843     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12755    | 0.12755    | 0.12755    |   0.0 |  0.39
Output  | 0.00024991 | 0.00024991 | 0.00024991 |   0.0 |  0.00
Modify  | 0.37009    | 0.37009    | 0.37009    |   0.0 |  1.14
Other   |            | 0.06428    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5501.00 ave        5501 max        5501 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350498.0 ave      350498 max      350498 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350498
Ave neighs/atom = 175.24900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.431751582718, Press = -1.03330225666191
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  102000   -8208.2442   -8208.2442   -8277.9783   -8277.9783    269.87832    269.87832    22201.092    22201.092    1971.2302    1971.2302 
  103000   -8205.8833   -8205.8833   -8277.6419   -8277.6419    277.71339    277.71339     22215.16     22215.16    1402.2022    1402.2022 
Loop time of 33.0562 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.614 ns/day, 9.182 hours/ns, 30.252 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.483     | 32.483     | 32.483     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13028    | 0.13028    | 0.13028    |   0.0 |  0.39
Output  | 0.00015587 | 0.00015587 | 0.00015587 |   0.0 |  0.00
Modify  | 0.37782    | 0.37782    | 0.37782    |   0.0 |  1.14
Other   |            | 0.06476    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5542.00 ave        5542 max        5542 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351506.0 ave      351506 max      351506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351506
Ave neighs/atom = 175.75300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.405252015287, Press = -0.400572902837651
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  103000   -8205.8833   -8205.8833   -8277.6419   -8277.6419    277.71339    277.71339     22215.16     22215.16    1402.2022    1402.2022 
  104000   -8208.0913   -8208.0913   -8276.7117   -8276.7117    265.56834    265.56834    22253.209    22253.209   -1513.1444   -1513.1444 
Loop time of 32.3857 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.668 ns/day, 8.996 hours/ns, 30.878 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    | 31.821     | 31.821     | 31.821     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12878    | 0.12878    | 0.12878    |   0.0 |  0.40
Output  | 0.00015814 | 0.00015814 | 0.00015814 |   0.0 |  0.00
Modify  | 0.37105    | 0.37105    | 0.37105    |   0.0 |  1.15
Other   |            | 0.06464    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5512.00 ave        5512 max        5512 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351362.0 ave      351362 max      351362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351362
Ave neighs/atom = 175.68100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.404600006358, Press = 0.0933994995823877
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  104000   -8208.0913   -8208.0913   -8276.7117   -8276.7117    265.56834    265.56834    22253.209    22253.209   -1513.1444   -1513.1444 
  105000   -8203.9844   -8203.9844   -8274.9488   -8274.9488    274.63989    274.63989    22267.684    22267.684   -2169.3351   -2169.3351 
Loop time of 32.4216 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.665 ns/day, 9.006 hours/ns, 30.844 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.862     | 31.862     | 31.862     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12805    | 0.12805    | 0.12805    |   0.0 |  0.39
Output  | 0.00020223 | 0.00020223 | 0.00020223 |   0.0 |  0.00
Modify  | 0.36743    | 0.36743    | 0.36743    |   0.0 |  1.13
Other   |            | 0.06418    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5524.00 ave        5524 max        5524 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350580.0 ave      350580 max      350580 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350580
Ave neighs/atom = 175.29000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.421623595299, Press = -1.70635708977179
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  105000   -8203.9844   -8203.9844   -8274.9488   -8274.9488    274.63989    274.63989    22267.684    22267.684   -2169.3351   -2169.3351 
  106000   -8205.3115   -8205.3115   -8277.9136   -8277.9136    280.97752    280.97752    22203.493    22203.493    2140.5464    2140.5464 
Loop time of 33.3891 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.588 ns/day, 9.275 hours/ns, 29.950 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.808     | 32.808     | 32.808     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13141    | 0.13141    | 0.13141    |   0.0 |  0.39
Output  | 0.00015338 | 0.00015338 | 0.00015338 |   0.0 |  0.00
Modify  | 0.38396    | 0.38396    | 0.38396    |   0.0 |  1.15
Other   |            | 0.06553    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5533.00 ave        5533 max        5533 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350294.0 ave      350294 max      350294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350294
Ave neighs/atom = 175.14700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.418146814886, Press = -0.175398842999293
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  106000   -8205.3115   -8205.3115   -8277.9136   -8277.9136    280.97752    280.97752    22203.493    22203.493    2140.5464    2140.5464 
  107000   -8211.0408   -8211.0408   -8278.5855   -8278.5855    261.40484    261.40484    22239.926    22239.926   -1316.4325   -1316.4325 
Loop time of 33.4398 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.584 ns/day, 9.289 hours/ns, 29.904 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.86      | 32.86      | 32.86      |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1321     | 0.1321     | 0.1321     |   0.0 |  0.40
Output  | 0.00018846 | 0.00018846 | 0.00018846 |   0.0 |  0.00
Modify  | 0.38238    | 0.38238    | 0.38238    |   0.0 |  1.14
Other   |            | 0.06488    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5556.00 ave        5556 max        5556 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351470.0 ave      351470 max      351470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351470
Ave neighs/atom = 175.73500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.397260504817, Press = 0.0683753066465414
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  107000   -8211.0408   -8211.0408   -8278.5855   -8278.5855    261.40484    261.40484    22239.926    22239.926   -1316.4325   -1316.4325 
  108000   -8206.0558   -8206.0558   -8278.3687   -8278.3687    279.85864    279.85864    22260.338    22260.338   -2835.4384   -2835.4384 
Loop time of 32.4718 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.661 ns/day, 9.020 hours/ns, 30.796 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.905     | 31.905     | 31.905     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12976    | 0.12976    | 0.12976    |   0.0 |  0.40
Output  | 0.00023109 | 0.00023109 | 0.00023109 |   0.0 |  0.00
Modify  | 0.37194    | 0.37194    | 0.37194    |   0.0 |  1.15
Other   |            | 0.06452    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5541.00 ave        5541 max        5541 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350688.0 ave      350688 max      350688 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350688
Ave neighs/atom = 175.34400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.385086547323, Press = -1.03859188057616
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  108000   -8206.0558   -8206.0558   -8278.3687   -8278.3687    279.85864    279.85864    22260.338    22260.338   -2835.4384   -2835.4384 
  109000   -8207.5027   -8207.5027   -8277.5384   -8277.5384    271.04551    271.04551    22205.839    22205.839    1963.0845    1963.0845 
Loop time of 32.731 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.640 ns/day, 9.092 hours/ns, 30.552 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.165     | 32.165     | 32.165     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12864    | 0.12864    | 0.12864    |   0.0 |  0.39
Output  | 0.00015648 | 0.00015648 | 0.00015648 |   0.0 |  0.00
Modify  | 0.37261    | 0.37261    | 0.37261    |   0.0 |  1.14
Other   |            | 0.06439    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5515.00 ave        5515 max        5515 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350772.0 ave      350772 max      350772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350772
Ave neighs/atom = 175.38600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.370032203528, Press = -0.324767709996152
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  109000   -8207.5027   -8207.5027   -8277.5384   -8277.5384    271.04551    271.04551    22205.839    22205.839    1963.0845    1963.0845 
  110000   -8209.4846   -8209.4846   -8278.8053   -8278.8053    268.27796    268.27796    22229.106    22229.106    -227.5419    -227.5419 
Loop time of 32.101 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.692 ns/day, 8.917 hours/ns, 31.152 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.544     | 31.544     | 31.544     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12752    | 0.12752    | 0.12752    |   0.0 |  0.40
Output  | 0.00015306 | 0.00015306 | 0.00015306 |   0.0 |  0.00
Modify  | 0.36539    | 0.36539    | 0.36539    |   0.0 |  1.14
Other   |            | 0.06434    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5526.00 ave        5526 max        5526 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351546.0 ave      351546 max      351546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351546
Ave neighs/atom = 175.77300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.36701272882, Press = -0.116133661872756
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  110000   -8209.4846   -8209.4846   -8278.8053   -8278.8053    268.27796    268.27796    22229.106    22229.106    -227.5419    -227.5419 
  111000   -8206.6419   -8206.6419   -8277.9836   -8277.9836    276.09966    276.09966    22236.828    22236.828    -277.1027    -277.1027 
Loop time of 32.5954 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.651 ns/day, 9.054 hours/ns, 30.679 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.033     | 32.033     | 32.033     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12893    | 0.12893    | 0.12893    |   0.0 |  0.40
Output  | 0.00015355 | 0.00015355 | 0.00015355 |   0.0 |  0.00
Modify  | 0.36857    | 0.36857    | 0.36857    |   0.0 |  1.13
Other   |            | 0.06435    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5521.00 ave        5521 max        5521 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350784.0 ave      350784 max      350784 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350784
Ave neighs/atom = 175.39200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.357132431975, Press = -0.481605741201469
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  111000   -8206.6419   -8206.6419   -8277.9836   -8277.9836    276.09966    276.09966    22236.828    22236.828    -277.1027    -277.1027 
  112000   -8210.1276   -8210.1276   -8278.4092   -8278.4092    264.25686    264.25686    22243.925    22243.925   -1557.1954   -1557.1954 
Loop time of 32.481 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.660 ns/day, 9.023 hours/ns, 30.787 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.915     | 31.915     | 31.915     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12917    | 0.12917    | 0.12917    |   0.0 |  0.40
Output  | 0.00015738 | 0.00015738 | 0.00015738 |   0.0 |  0.00
Modify  | 0.37198    | 0.37198    | 0.37198    |   0.0 |  1.15
Other   |            | 0.06515    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5515.00 ave        5515 max        5515 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351066.0 ave      351066 max      351066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351066
Ave neighs/atom = 175.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 = 273.338089506986, Press = -0.374415430064513
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  112000   -8210.1276   -8210.1276   -8278.4092   -8278.4092    264.25686    264.25686    22243.925    22243.925   -1557.1954   -1557.1954 
  113000   -8206.8068   -8206.8068   -8278.4054   -8278.4054     277.0939     277.0939    22200.739    22200.739    2483.6028    2483.6028 
Loop time of 32.7229 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.640 ns/day, 9.090 hours/ns, 30.560 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.154     | 32.154     | 32.154     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13       | 0.13       | 0.13       |   0.0 |  0.40
Output  | 0.00015593 | 0.00015593 | 0.00015593 |   0.0 |  0.00
Modify  | 0.37476    | 0.37476    | 0.37476    |   0.0 |  1.15
Other   |            | 0.06438    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5530.00 ave        5530 max        5530 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350794.0 ave      350794 max      350794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350794
Ave neighs/atom = 175.39700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.330808262903, Press = -0.552690919849501
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  113000   -8206.8068   -8206.8068   -8278.4054   -8278.4054     277.0939     277.0939    22200.739    22200.739    2483.6028    2483.6028 
  114000    -8207.056    -8207.056   -8280.2229   -8280.2229    283.16325    283.16325    22223.178    22223.178   -62.688905   -62.688905 
Loop time of 33.1716 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.605 ns/day, 9.214 hours/ns, 30.146 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.602     | 32.602     | 32.602     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13001    | 0.13001    | 0.13001    |   0.0 |  0.39
Output  | 0.0001565  | 0.0001565  | 0.0001565  |   0.0 |  0.00
Modify  | 0.37546    | 0.37546    | 0.37546    |   0.0 |  1.13
Other   |            | 0.06364    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5523.00 ave        5523 max        5523 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351548.0 ave      351548 max      351548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351548
Ave neighs/atom = 175.77400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.319193190189, Press = 0.339279612107745
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  114000    -8207.056    -8207.056   -8280.2229   -8280.2229    283.16325    283.16325    22223.178    22223.178   -62.688905   -62.688905 
  115000   -8209.4706   -8209.4706   -8279.3176   -8279.3176    270.31505    270.31505    22242.116    22242.116   -1575.5542   -1575.5542 
Loop time of 33.0222 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.616 ns/day, 9.173 hours/ns, 30.283 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.452     | 32.452     | 32.452     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12902    | 0.12902    | 0.12902    |   0.0 |  0.39
Output  | 0.00019531 | 0.00019531 | 0.00019531 |   0.0 |  0.00
Modify  | 0.37593    | 0.37593    | 0.37593    |   0.0 |  1.14
Other   |            | 0.06458    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5513.00 ave        5513 max        5513 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351254.0 ave      351254 max      351254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351254
Ave neighs/atom = 175.62700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.328028478379, Press = -0.680891826283957
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  115000   -8209.4706   -8209.4706   -8279.3176   -8279.3176    270.31505    270.31505    22242.116    22242.116   -1575.5542   -1575.5542 
  116000   -8206.7194   -8206.7194   -8278.3062   -8278.3062    277.04825    277.04825    22226.684    22226.684    116.60748    116.60748 
Loop time of 33.1612 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.605 ns/day, 9.211 hours/ns, 30.156 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.58      | 32.58      | 32.58      |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13103    | 0.13103    | 0.13103    |   0.0 |  0.40
Output  | 0.00015841 | 0.00015841 | 0.00015841 |   0.0 |  0.00
Modify  | 0.38453    | 0.38453    | 0.38453    |   0.0 |  1.16
Other   |            | 0.06586    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5521.00 ave        5521 max        5521 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350550.0 ave      350550 max      350550 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350550
Ave neighs/atom = 175.27500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.317875785596, Press = -0.334084024757475
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  116000   -8206.7194   -8206.7194   -8278.3062   -8278.3062    277.04825    277.04825    22226.684    22226.684    116.60748    116.60748 
  117000   -8209.0774   -8209.0774   -8277.9942   -8277.9942    266.71502    266.71502    22216.759    22216.759    472.09253    472.09253 
Loop time of 32.3752 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.669 ns/day, 8.993 hours/ns, 30.888 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.81      | 31.81      | 31.81      |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12946    | 0.12946    | 0.12946    |   0.0 |  0.40
Output  | 0.00015647 | 0.00015647 | 0.00015647 |   0.0 |  0.00
Modify  | 0.37027    | 0.37027    | 0.37027    |   0.0 |  1.14
Other   |            | 0.06495    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5531.00 ave        5531 max        5531 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351216.0 ave      351216 max      351216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351216
Ave neighs/atom = 175.60800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.295948824172, Press = -0.217656227735272
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  117000   -8209.0774   -8209.0774   -8277.9942   -8277.9942    266.71502    266.71502    22216.759    22216.759    472.09253    472.09253 
  118000   -8204.1155   -8204.1155   -8276.0855   -8276.0855    278.53134    278.53134    22230.124    22230.124    727.55927    727.55927 
Loop time of 32.9869 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.619 ns/day, 9.163 hours/ns, 30.315 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.414     | 32.414     | 32.414     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12998    | 0.12998    | 0.12998    |   0.0 |  0.39
Output  | 0.00015605 | 0.00015605 | 0.00015605 |   0.0 |  0.00
Modify  | 0.37841    | 0.37841    | 0.37841    |   0.0 |  1.15
Other   |            | 0.06444    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5530.00 ave        5530 max        5530 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351042.0 ave      351042 max      351042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351042
Ave neighs/atom = 175.52100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.31094483388, Press = -0.608504657638798
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  118000   -8204.1155   -8204.1155   -8276.0855   -8276.0855    278.53134    278.53134    22230.124    22230.124    727.55927    727.55927 
  119000   -8206.9288   -8206.9288   -8279.0113   -8279.0113    278.96675    278.96675    22234.896    22234.896   -769.90352   -769.90352 
Loop time of 33.0513 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.483     | 32.483     | 32.483     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13034    | 0.13034    | 0.13034    |   0.0 |  0.39
Output  | 0.00015431 | 0.00015431 | 0.00015431 |   0.0 |  0.00
Modify  | 0.37323    | 0.37323    | 0.37323    |   0.0 |  1.13
Other   |            | 0.06423    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5522.00 ave        5522 max        5522 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350936.0 ave      350936 max      350936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350936
Ave neighs/atom = 175.46800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.320686253462, Press = -0.410736481866128
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  119000   -8206.9288   -8206.9288   -8279.0113   -8279.0113    278.96675    278.96675    22234.896    22234.896   -769.90352   -769.90352 
  120000   -8207.4118   -8207.4118   -8276.5126   -8276.5126    267.42733    267.42733    22225.932    22225.932    384.23309    384.23309 
Loop time of 33.5392 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.576 ns/day, 9.316 hours/ns, 29.816 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.955     | 32.955     | 32.955     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13318    | 0.13318    | 0.13318    |   0.0 |  0.40
Output  | 0.00015621 | 0.00015621 | 0.00015621 |   0.0 |  0.00
Modify  | 0.38588    | 0.38588    | 0.38588    |   0.0 |  1.15
Other   |            | 0.06534    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5531.00 ave        5531 max        5531 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350904.0 ave      350904 max      350904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350904
Ave neighs/atom = 175.45200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.329431825863, Press = -0.549459139235174
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  120000   -8207.4118   -8207.4118   -8276.5126   -8276.5126    267.42733    267.42733    22225.932    22225.932    384.23309    384.23309 
  121000   -8205.4402   -8205.4402   -8278.5382   -8278.5382    282.89658    282.89658    22214.713    22214.713    1058.0309    1058.0309 
Loop time of 32.1629 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.686 ns/day, 8.934 hours/ns, 31.092 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.606     | 31.606     | 31.606     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12734    | 0.12734    | 0.12734    |   0.0 |  0.40
Output  | 0.00015011 | 0.00015011 | 0.00015011 |   0.0 |  0.00
Modify  | 0.36462    | 0.36462    | 0.36462    |   0.0 |  1.13
Other   |            | 0.06485    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5539.00 ave        5539 max        5539 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351108.0 ave      351108 max      351108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 351108
Ave neighs/atom = 175.55400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.325604144439, Press = -0.808966454468137
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.80375
  ghost atom cutoff = 7.80375
  binsize = 3.901875, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.80375
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.578 | 4.578 | 4.578 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  121000   -8205.4402   -8205.4402   -8278.5382   -8278.5382    282.89658    282.89658    22214.713    22214.713    1058.0309    1058.0309 
  122000   -8209.6022   -8209.6022   -8278.1519   -8278.1519    265.29434    265.29434    22206.067    22206.067    1421.7593    1421.7593 
Loop time of 33.2909 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.595 ns/day, 9.247 hours/ns, 30.038 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.709     | 32.709     | 32.709     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13283    | 0.13283    | 0.13283    |   0.0 |  0.40
Output  | 0.000157   | 0.000157   | 0.000157   |   0.0 |  0.00
Modify  | 0.38378    | 0.38378    | 0.38378    |   0.0 |  1.15
Other   |            | 0.06548    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5526.00 ave        5526 max        5526 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      351338.0 ave      351338 max      351338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0