# 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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   -8202.9009   -8202.9009   -8288.9838   -8288.9838       333.15       333.15    21829.486    21829.486    4212.0519    4212.0519 
    1000   -8153.3259   -8153.3259   -8237.5576   -8237.5576    325.98514    325.98514    22440.696    22440.696    -2202.752    -2202.752 
Loop time of 31.2644 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.764 ns/day, 8.685 hours/ns, 31.985 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.62      | 30.62      | 30.62      |   0.0 | 97.94
Neigh   | 0.095379   | 0.095379   | 0.095379   |   0.0 |  0.31
Comm    | 0.12994    | 0.12994    | 0.12994    |   0.0 |  0.42
Output  | 0.00019816 | 0.00019816 | 0.00019816 |   0.0 |  0.00
Modify  | 0.35326    | 0.35326    | 0.35326    |   0.0 |  1.13
Other   |            | 0.06552    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5474.00 ave        5474 max        5474 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      340164.0 ave      340164 max      340164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 340164
Ave neighs/atom = 170.08200
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   -8153.3259   -8153.3259   -8237.5576   -8237.5576    325.98514    325.98514    22440.696    22440.696    -2202.752    -2202.752 
    2000   -8164.2116   -8164.2116   -8253.5921   -8253.5921    345.91193    345.91193    22353.255    22353.255    109.42028    109.42028 
Loop time of 32.3295 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.738     | 31.738     | 31.738     |   0.0 | 98.17
Neigh   | 0.047529   | 0.047529   | 0.047529   |   0.0 |  0.15
Comm    | 0.12796    | 0.12796    | 0.12796    |   0.0 |  0.40
Output  | 0.00018878 | 0.00018878 | 0.00018878 |   0.0 |  0.00
Modify  | 0.35044    | 0.35044    | 0.35044    |   0.0 |  1.08
Other   |            | 0.06584    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5476.00 ave        5476 max        5476 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      344946.0 ave      344946 max      344946 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 344946
Ave neighs/atom = 172.47300
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   -8164.2116   -8164.2116   -8253.5921   -8253.5921    345.91193    345.91193    22353.255    22353.255    109.42028    109.42028 
    3000   -8177.2022   -8177.2022   -8261.7472   -8261.7472    327.19787    327.19787    22317.375    22317.375   -1100.1442   -1100.1442 
Loop time of 32.3509 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.671 ns/day, 8.986 hours/ns, 30.911 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.764     | 31.764     | 31.764     |   0.0 | 98.19
Neigh   | 0.047754   | 0.047754   | 0.047754   |   0.0 |  0.15
Comm    | 0.12688    | 0.12688    | 0.12688    |   0.0 |  0.39
Output  | 0.00019284 | 0.00019284 | 0.00019284 |   0.0 |  0.00
Modify  | 0.34575    | 0.34575    | 0.34575    |   0.0 |  1.07
Other   |            | 0.06621    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5504.00 ave        5504 max        5504 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      349206.0 ave      349206 max      349206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349206
Ave neighs/atom = 174.60300
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   -8177.2022   -8177.2022   -8261.7472   -8261.7472    327.19787    327.19787    22317.375    22317.375   -1100.1442   -1100.1442 
    4000    -8170.765    -8170.765   -8257.9423   -8257.9423    337.38501    337.38501     22290.71     22290.71    2329.8174    2329.8174 
Loop time of 32.0936 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.555     | 31.555     | 31.555     |   0.0 | 98.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12644    | 0.12644    | 0.12644    |   0.0 |  0.39
Output  | 0.0002342  | 0.0002342  | 0.0002342  |   0.0 |  0.00
Modify  | 0.34674    | 0.34674    | 0.34674    |   0.0 |  1.08
Other   |            | 0.06565    |            |       |  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:      348722.0 ave      348722 max      348722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 348722
Ave neighs/atom = 174.36100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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    -8170.765    -8170.765   -8257.9423   -8257.9423    337.38501    337.38501     22290.71     22290.71    2329.8174    2329.8174 
    5000    -8176.543    -8176.543   -8263.0343   -8263.0343    334.73028    334.73028    22311.619    22311.619   -633.68581   -633.68581 
Loop time of 32.1647 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.623     | 31.623     | 31.623     |   0.0 | 98.31
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12743    | 0.12743    | 0.12743    |   0.0 |  0.40
Output  | 0.00015528 | 0.00015528 | 0.00015528 |   0.0 |  0.00
Modify  | 0.34877    | 0.34877    | 0.34877    |   0.0 |  1.08
Other   |            | 0.06581    |            |       |  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:      349536.0 ave      349536 max      349536 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349536
Ave neighs/atom = 174.76800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 331.269680565129, Press = -1103.72770407674
next a
jump SELF top
variable a loop 2000
run 1000
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    -8176.543    -8176.543   -8263.0343   -8263.0343    334.73028    334.73028    22311.619    22311.619   -633.68581   -633.68581 
    6000   -8177.4059   -8177.4059   -8260.4104   -8260.4104    321.23604    321.23604    22322.554    22322.554   -919.53823   -919.53823 
Loop time of 32.8249 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.632 ns/day, 9.118 hours/ns, 30.465 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.249     | 32.249     | 32.249     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12969    | 0.12969    | 0.12969    |   0.0 |  0.40
Output  | 0.00015422 | 0.00015422 | 0.00015422 |   0.0 |  0.00
Modify  | 0.37908    | 0.37908    | 0.37908    |   0.0 |  1.15
Other   |            | 0.06692    |            |       |  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:      349428.0 ave      349428 max      349428 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349428
Ave neighs/atom = 174.71400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.335313656323, Press = -12.7947279264895
next a
jump SELF top
variable a loop 2000
run 1000
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   -8177.4059   -8177.4059   -8260.4104   -8260.4104    321.23604    321.23604    22322.554    22322.554   -919.53823   -919.53823 
    7000   -8174.6575   -8174.6575   -8262.4962   -8262.4962    339.94517    339.94517    22301.286    22301.286    240.33212    240.33212 
Loop time of 32.9286 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.624 ns/day, 9.147 hours/ns, 30.369 timesteps/s
99.9% 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.364     | 32.364     | 32.364     |   0.0 | 98.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1283     | 0.1283     | 0.1283     |   0.0 |  0.39
Output  | 0.0001544  | 0.0001544  | 0.0001544  |   0.0 |  0.00
Modify  | 0.36981    | 0.36981    | 0.36981    |   0.0 |  1.12
Other   |            | 0.06602    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5493.00 ave        5493 max        5493 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      349178.0 ave      349178 max      349178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349178
Ave neighs/atom = 174.58900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.839450369607, Press = -16.2246367281826
next a
jump SELF top
variable a loop 2000
run 1000
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   -8174.6575   -8174.6575   -8262.4962   -8262.4962    339.94517    339.94517    22301.286    22301.286    240.33212    240.33212 
    8000   -8174.0982   -8174.0982   -8261.0006   -8261.0006    336.32116    336.32116     22299.68     22299.68    552.87631    552.87631 
Loop time of 33.0026 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.427     | 32.427     | 32.427     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12977    | 0.12977    | 0.12977    |   0.0 |  0.39
Output  | 0.00015353 | 0.00015353 | 0.00015353 |   0.0 |  0.00
Modify  | 0.37893    | 0.37893    | 0.37893    |   0.0 |  1.15
Other   |            | 0.06675    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5508.00 ave        5508 max        5508 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      349596.0 ave      349596 max      349596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349596
Ave neighs/atom = 174.79800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.111173796513, Press = -61.7121155125972
next a
jump SELF top
variable a loop 2000
run 1000
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   -8174.0982   -8174.0982   -8261.0006   -8261.0006    336.32116    336.32116     22299.68     22299.68    552.87631    552.87631 
    9000   -8179.0159   -8179.0159   -8263.8238   -8263.8238    328.21525    328.21525    22326.662    22326.662   -2465.3126   -2465.3126 
Loop time of 33.0755 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.612 ns/day, 9.188 hours/ns, 30.234 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.505     | 32.505     | 32.505     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12954    | 0.12954    | 0.12954    |   0.0 |  0.39
Output  | 0.00025166 | 0.00025166 | 0.00025166 |   0.0 |  0.00
Modify  | 0.37499    | 0.37499    | 0.37499    |   0.0 |  1.13
Other   |            | 0.06615    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5545.00 ave        5545 max        5545 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      349750.0 ave      349750 max      349750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349750
Ave neighs/atom = 174.87500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.120231596151, Press = -10.2493319960332
next a
jump SELF top
variable a loop 2000
run 1000
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   -8179.0159   -8179.0159   -8263.8238   -8263.8238    328.21525    328.21525    22326.662    22326.662   -2465.3126   -2465.3126 
   10000   -8171.9005   -8171.9005   -8258.0808   -8258.0808     333.5269     333.5269    22295.838    22295.838    1759.6923    1759.6923 
Loop time of 33.0746 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.612 ns/day, 9.187 hours/ns, 30.235 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.499     | 32.499     | 32.499     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12991    | 0.12991    | 0.12991    |   0.0 |  0.39
Output  | 0.00019868 | 0.00019868 | 0.00019868 |   0.0 |  0.00
Modify  | 0.37895    | 0.37895    | 0.37895    |   0.0 |  1.15
Other   |            | 0.06684    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5514.00 ave        5514 max        5514 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      349396.0 ave      349396 max      349396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349396
Ave neighs/atom = 174.69800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.278560116731, Press = -10.9846710712801
next a
jump SELF top
variable a loop 2000
run 1000
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   -8171.9005   -8171.9005   -8258.0808   -8258.0808     333.5269     333.5269    22295.838    22295.838    1759.6923    1759.6923 
   11000   -8177.8931   -8177.8931   -8262.0061   -8262.0061    325.52579    325.52579    22318.477    22318.477   -1138.1813   -1138.1813 
Loop time of 32.776 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.205     | 32.205     | 32.205     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13014    | 0.13014    | 0.13014    |   0.0 |  0.40
Output  | 0.00015631 | 0.00015631 | 0.00015631 |   0.0 |  0.00
Modify  | 0.37447    | 0.37447    | 0.37447    |   0.0 |  1.14
Other   |            | 0.06668    |            |       |  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:      349876.0 ave      349876 max      349876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349876
Ave neighs/atom = 174.93800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.53080942558, Press = -14.6843720267533
next a
jump SELF top
variable a loop 2000
run 1000
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   -8177.8931   -8177.8931   -8262.0061   -8262.0061    325.52579    325.52579    22318.477    22318.477   -1138.1813   -1138.1813 
   12000     -8176.01     -8176.01   -8260.5984   -8260.5984    327.36585    327.36585     22300.64     22300.64    703.27521    703.27521 
Loop time of 33.3244 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.593 ns/day, 9.257 hours/ns, 30.008 timesteps/s
99.9% 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.752     | 32.752     | 32.752     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12886    | 0.12886    | 0.12886    |   0.0 |  0.39
Output  | 0.00015411 | 0.00015411 | 0.00015411 |   0.0 |  0.00
Modify  | 0.37748    | 0.37748    | 0.37748    |   0.0 |  1.13
Other   |            | 0.0657     |            |       |  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:      349344.0 ave      349344 max      349344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349344
Ave neighs/atom = 174.67200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.395986339196, Press = 1.49633043374818
next a
jump SELF top
variable a loop 2000
run 1000
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     -8176.01     -8176.01   -8260.5984   -8260.5984    327.36585    327.36585     22300.64     22300.64    703.27521    703.27521 
   13000   -8178.3331   -8178.3331   -8264.5454   -8264.5454    333.65052    333.65052    22239.617    22239.617    4486.7182    4486.7182 
Loop time of 33.1938 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.603 ns/day, 9.221 hours/ns, 30.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    | 32.617     | 32.617     | 32.617     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13057    | 0.13057    | 0.13057    |   0.0 |  0.39
Output  | 0.00015208 | 0.00015208 | 0.00015208 |   0.0 |  0.00
Modify  | 0.37982    | 0.37982    | 0.37982    |   0.0 |  1.14
Other   |            | 0.06629    |            |       |  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:      349488.0 ave      349488 max      349488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349488
Ave neighs/atom = 174.74400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.115726051451, Press = -18.0466707631045
next a
jump SELF top
variable a loop 2000
run 1000
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   -8178.3331   -8178.3331   -8264.5454   -8264.5454    333.65052    333.65052    22239.617    22239.617    4486.7182    4486.7182 
   14000    -8172.458    -8172.458   -8258.6389   -8258.6389    333.52886    333.52886     22349.53     22349.53   -2549.0381   -2549.0381 
Loop time of 33.0967 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.611 ns/day, 9.194 hours/ns, 30.214 timesteps/s
99.9% 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.522     | 32.522     | 32.522     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12918    | 0.12918    | 0.12918    |   0.0 |  0.39
Output  | 0.00015795 | 0.00015795 | 0.00015795 |   0.0 |  0.00
Modify  | 0.3785     | 0.3785     | 0.3785     |   0.0 |  1.14
Other   |            | 0.06694    |            |       |  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:      350826.0 ave      350826 max      350826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350826
Ave neighs/atom = 175.41300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.101700562708, Press = -9.82711130835012
next a
jump SELF top
variable a loop 2000
run 1000
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    -8172.458    -8172.458   -8258.6389   -8258.6389    333.52886    333.52886     22349.53     22349.53   -2549.0381   -2549.0381 
   15000   -8176.0316   -8176.0316   -8262.4837   -8262.4837    334.57855    334.57855    22332.449    22332.449   -2183.8686   -2183.8686 
Loop time of 33.5713 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.574 ns/day, 9.325 hours/ns, 29.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    | 32.985     | 32.985     | 32.985     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13304    | 0.13304    | 0.13304    |   0.0 |  0.40
Output  | 0.00019796 | 0.00019796 | 0.00019796 |   0.0 |  0.00
Modify  | 0.3865     | 0.3865     | 0.3865     |   0.0 |  1.15
Other   |            | 0.06644    |            |       |  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:      348904.0 ave      348904 max      348904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 348904
Ave neighs/atom = 174.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 = 334.373476004468, Press = -2.77786401614634
next a
jump SELF top
variable a loop 2000
run 1000
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   -8176.0316   -8176.0316   -8262.4837   -8262.4837    334.57855    334.57855    22332.449    22332.449   -2183.8686   -2183.8686 
   16000   -8174.6257   -8174.6257   -8259.2638   -8259.2638    327.55806    327.55806    22297.227    22297.227    1558.9839    1558.9839 
Loop time of 33.1466 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.573     | 32.573     | 32.573     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12998    | 0.12998    | 0.12998    |   0.0 |  0.39
Output  | 0.00014994 | 0.00014994 | 0.00014994 |   0.0 |  0.00
Modify  | 0.37722    | 0.37722    | 0.37722    |   0.0 |  1.14
Other   |            | 0.06614    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5508.00 ave        5508 max        5508 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      348706.0 ave      348706 max      348706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 348706
Ave neighs/atom = 174.35300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.258532506466, Press = 4.4999780073837
next a
jump SELF top
variable a loop 2000
run 1000
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   -8174.6257   -8174.6257   -8259.2638   -8259.2638    327.55806    327.55806    22297.227    22297.227    1558.9839    1558.9839 
   17000   -8177.7465   -8177.7465   -8261.6225   -8261.6225    324.60898    324.60898    22278.614    22278.614    1844.0908    1844.0908 
Loop time of 33.2297 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.600 ns/day, 9.230 hours/ns, 30.094 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.65      | 32.65      | 32.65      |   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.00015531 | 0.00015531 | 0.00015531 |   0.0 |  0.00
Modify  | 0.38237    | 0.38237    | 0.38237    |   0.0 |  1.15
Other   |            | 0.06594    |            |       |  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:      349712.0 ave      349712 max      349712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349712
Ave neighs/atom = 174.85600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.269222641288, Press = -8.71439571243167
next a
jump SELF top
variable a loop 2000
run 1000
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   -8177.7465   -8177.7465   -8261.6225   -8261.6225    324.60898    324.60898    22278.614    22278.614    1844.0908    1844.0908 
   18000   -8172.2586   -8172.2586   -8261.0987   -8261.0987    343.82061    343.82061    22306.933    22306.933    45.751177    45.751177 
Loop time of 33.3282 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.592 ns/day, 9.258 hours/ns, 30.005 timesteps/s
99.9% 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.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13007    | 0.13007    | 0.13007    |   0.0 |  0.39
Output  | 0.00015778 | 0.00015778 | 0.00015778 |   0.0 |  0.00
Modify  | 0.38471    | 0.38471    | 0.38471    |   0.0 |  1.15
Other   |            | 0.06697    |            |       |  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:      350202.0 ave      350202 max      350202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350202
Ave neighs/atom = 175.10100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.171600025312, Press = -6.10759135585272
next a
jump SELF top
variable a loop 2000
run 1000
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   -8172.2586   -8172.2586   -8261.0987   -8261.0987    343.82061    343.82061    22306.933    22306.933    45.751177    45.751177 
   19000   -8175.5597   -8175.5597     -8261.02     -8261.02    330.74002    330.74002    22326.762    22326.762   -1640.5154   -1640.5154 
Loop time of 33.5794 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.573 ns/day, 9.328 hours/ns, 29.780 timesteps/s
99.9% 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.999     | 32.999     | 32.999     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13085    | 0.13085    | 0.13085    |   0.0 |  0.39
Output  | 0.00019609 | 0.00019609 | 0.00019609 |   0.0 |  0.00
Modify  | 0.38252    | 0.38252    | 0.38252    |   0.0 |  1.14
Other   |            | 0.06664    |            |       |  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:      349598.0 ave      349598 max      349598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349598
Ave neighs/atom = 174.79900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.120234581301, Press = -6.19991552284883
next a
jump SELF top
variable a loop 2000
run 1000
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   -8175.5597   -8175.5597     -8261.02     -8261.02    330.74002    330.74002    22326.762    22326.762   -1640.5154   -1640.5154 
   20000   -8180.7689   -8180.7689   -8264.0974   -8264.0974    322.48994    322.48994    22318.162    22318.162   -1636.9672   -1636.9672 
Loop time of 32.7637 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.637 ns/day, 9.101 hours/ns, 30.522 timesteps/s
99.9% 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.197     | 32.197     | 32.197     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12833    | 0.12833    | 0.12833    |   0.0 |  0.39
Output  | 0.00015652 | 0.00015652 | 0.00015652 |   0.0 |  0.00
Modify  | 0.37147    | 0.37147    | 0.37147    |   0.0 |  1.13
Other   |            | 0.06649    |            |       |  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:      349138.0 ave      349138 max      349138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349138
Ave neighs/atom = 174.56900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.001983602995, Press = 1.3646714706725
next a
jump SELF top
variable a loop 2000
run 1000
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   -8180.7689   -8180.7689   -8264.0974   -8264.0974    322.48994    322.48994    22318.162    22318.162   -1636.9672   -1636.9672 
   21000   -8175.1736   -8175.1736   -8261.1332   -8261.1332    332.67263    332.67263    22275.573    22275.573    2428.5088    2428.5088 
Loop time of 32.4725 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.661 ns/day, 9.020 hours/ns, 30.795 timesteps/s
99.9% 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.91      | 31.91      | 31.91      |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12823    | 0.12823    | 0.12823    |   0.0 |  0.39
Output  | 0.00015547 | 0.00015547 | 0.00015547 |   0.0 |  0.00
Modify  | 0.36812    | 0.36812    | 0.36812    |   0.0 |  1.13
Other   |            | 0.06631    |            |       |  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:      349324.0 ave      349324 max      349324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349324
Ave neighs/atom = 174.66200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.85793286935, Press = -3.83395425607981
next a
jump SELF top
variable a loop 2000
run 1000
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   -8175.1736   -8175.1736   -8261.1332   -8261.1332    332.67263    332.67263    22275.573    22275.573    2428.5088    2428.5088 
   22000   -8178.3221   -8178.3221   -8262.3413   -8262.3413    325.16303    325.16303    22309.091    22309.091   -395.37973   -395.37973 
Loop time of 33.0887 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.611 ns/day, 9.191 hours/ns, 30.222 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.513     | 32.513     | 32.513     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12945    | 0.12945    | 0.12945    |   0.0 |  0.39
Output  | 0.00019833 | 0.00019833 | 0.00019833 |   0.0 |  0.00
Modify  | 0.37945    | 0.37945    | 0.37945    |   0.0 |  1.15
Other   |            | 0.06614    |            |       |  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:      350104.0 ave      350104 max      350104 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350104
Ave neighs/atom = 175.05200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.66882619684, Press = -5.47400410489539
next a
jump SELF top
variable a loop 2000
run 1000
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   -8178.3221   -8178.3221   -8262.3413   -8262.3413    325.16303    325.16303    22309.091    22309.091   -395.37973   -395.37973 
   23000   -8176.5707   -8176.5707   -8263.0959   -8263.0959    334.86126    334.86126    22324.559    22324.559   -2293.8773   -2293.8773 
Loop time of 33.3315 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.592 ns/day, 9.259 hours/ns, 30.002 timesteps/s
99.9% 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.752     | 32.752     | 32.752     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13041    | 0.13041    | 0.13041    |   0.0 |  0.39
Output  | 0.00020321 | 0.00020321 | 0.00020321 |   0.0 |  0.00
Modify  | 0.38298    | 0.38298    | 0.38298    |   0.0 |  1.15
Other   |            | 0.0663     |            |       |  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:      349666.0 ave      349666 max      349666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349666
Ave neighs/atom = 174.83300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.542251960327, Press = -1.89023168462956
next a
jump SELF top
variable a loop 2000
run 1000
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   -8176.5707   -8176.5707   -8263.0959   -8263.0959    334.86126    334.86126    22324.559    22324.559   -2293.8773   -2293.8773 
   24000   -8173.9046   -8173.9046   -8262.0059   -8262.0059    340.96137    340.96137    22289.381    22289.381    1054.3805    1054.3805 
Loop time of 32.933 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.624 ns/day, 9.148 hours/ns, 30.365 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.36      | 32.36      | 32.36      |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12941    | 0.12941    | 0.12941    |   0.0 |  0.39
Output  | 0.00015395 | 0.00015395 | 0.00015395 |   0.0 |  0.00
Modify  | 0.37678    | 0.37678    | 0.37678    |   0.0 |  1.14
Other   |            | 0.06686    |            |       |  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:      349434.0 ave      349434 max      349434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349434
Ave neighs/atom = 174.71700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.41276304458, Press = 3.47050647237734
next a
jump SELF top
variable a loop 2000
run 1000
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   -8173.9046   -8173.9046   -8262.0059   -8262.0059    340.96137    340.96137    22289.381    22289.381    1054.3805    1054.3805 
   25000   -8180.2405   -8180.2405   -8264.3225   -8264.3225    325.40612    325.40612    22287.827    22287.827    1161.8934    1161.8934 
Loop time of 33.2701 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.597 ns/day, 9.242 hours/ns, 30.057 timesteps/s
99.9% 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.69      | 32.69      | 32.69      |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13229    | 0.13229    | 0.13229    |   0.0 |  0.40
Output  | 0.0001558  | 0.0001558  | 0.0001558  |   0.0 |  0.00
Modify  | 0.38064    | 0.38064    | 0.38064    |   0.0 |  1.14
Other   |            | 0.06649    |            |       |  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:      349764.0 ave      349764 max      349764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349764
Ave neighs/atom = 174.88200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.238034584507, Press = -6.33308880377081
next a
jump SELF top
variable a loop 2000
run 1000
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   -8180.2405   -8180.2405   -8264.3225   -8264.3225    325.40612    325.40612    22287.827    22287.827    1161.8934    1161.8934 
   26000   -8175.8256   -8175.8256    -8261.022    -8261.022    329.71883    329.71883    22338.442    22338.442   -2752.8241   -2752.8241 
Loop time of 32.9595 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.621 ns/day, 9.155 hours/ns, 30.340 timesteps/s
99.9% 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.391     | 32.391     | 32.391     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12891    | 0.12891    | 0.12891    |   0.0 |  0.39
Output  | 0.00045185 | 0.00045185 | 0.00045185 |   0.0 |  0.00
Modify  | 0.37394    | 0.37394    | 0.37394    |   0.0 |  1.13
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:        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:      350266.0 ave      350266 max      350266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350266
Ave neighs/atom = 175.13300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.17906908887, Press = -1.93598583234201
next a
jump SELF top
variable a loop 2000
run 1000
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   -8175.8256   -8175.8256    -8261.022    -8261.022    329.71883    329.71883    22338.442    22338.442   -2752.8241   -2752.8241 
   27000   -8174.0443   -8174.0443   -8261.7418   -8261.7418    339.39851    339.39851    22307.245    22307.245     251.6028     251.6028 
Loop time of 33.442 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.584 ns/day, 9.289 hours/ns, 29.902 timesteps/s
99.9% 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.858     | 32.858     | 32.858     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13188    | 0.13188    | 0.13188    |   0.0 |  0.39
Output  | 0.00015662 | 0.00015662 | 0.00015662 |   0.0 |  0.00
Modify  | 0.38556    | 0.38556    | 0.38556    |   0.0 |  1.15
Other   |            | 0.06674    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5506.00 ave        5506 max        5506 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      349108.0 ave      349108 max      349108 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349108
Ave neighs/atom = 174.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 = 333.07407498105, Press = -2.29959510316992
next a
jump SELF top
variable a loop 2000
run 1000
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   -8174.0443   -8174.0443   -8261.7418   -8261.7418    339.39851    339.39851    22307.245    22307.245     251.6028     251.6028 
   28000   -8179.1873   -8179.1873   -8263.5211   -8263.5211    326.38056    326.38056    22303.697    22303.697   -492.80531   -492.80531 
Loop time of 32.6997 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.131     | 32.131     | 32.131     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12857    | 0.12857    | 0.12857    |   0.0 |  0.39
Output  | 0.00015446 | 0.00015446 | 0.00015446 |   0.0 |  0.00
Modify  | 0.37413    | 0.37413    | 0.37413    |   0.0 |  1.14
Other   |            | 0.06617    |            |       |  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:      349730.0 ave      349730 max      349730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349730
Ave neighs/atom = 174.86500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.094640916941, Press = -4.44314893042428
next a
jump SELF top
variable a loop 2000
run 1000
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   -8179.1873   -8179.1873   -8263.5211   -8263.5211    326.38056    326.38056    22303.697    22303.697   -492.80531   -492.80531 
   29000   -8173.7872   -8173.7872   -8260.3011   -8260.3011    334.81772    334.81772    22347.248    22347.248   -3067.6386   -3067.6386 
Loop time of 32.5298 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.656 ns/day, 9.036 hours/ns, 30.741 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.968     | 31.968     | 31.968     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12728    | 0.12728    | 0.12728    |   0.0 |  0.39
Output  | 0.00015593 | 0.00015593 | 0.00015593 |   0.0 |  0.00
Modify  | 0.36873    | 0.36873    | 0.36873    |   0.0 |  1.13
Other   |            | 0.06562    |            |       |  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:      349498.0 ave      349498 max      349498 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349498
Ave neighs/atom = 174.74900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.077742767907, Press = 1.23294186447487
next a
jump SELF top
variable a loop 2000
run 1000
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   -8173.7872   -8173.7872   -8260.3011   -8260.3011    334.81772    334.81772    22347.248    22347.248   -3067.6386   -3067.6386 
   30000   -8177.4737   -8177.4737   -8264.4186   -8264.4186     336.4855     336.4855    22252.218    22252.218    3544.0411    3544.0411 
Loop time of 33.6162 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.570 ns/day, 9.338 hours/ns, 29.748 timesteps/s
99.9% 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.031     | 33.031     | 33.031     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13122    | 0.13122    | 0.13122    |   0.0 |  0.39
Output  | 0.00015712 | 0.00015712 | 0.00015712 |   0.0 |  0.00
Modify  | 0.38681    | 0.38681    | 0.38681    |   0.0 |  1.15
Other   |            | 0.06714    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5508.00 ave        5508 max        5508 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      349136.0 ave      349136 max      349136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349136
Ave neighs/atom = 174.56800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.053520065365, Press = -1.66563146741082
next a
jump SELF top
variable a loop 2000
run 1000
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   -8177.4737   -8177.4737   -8264.4186   -8264.4186     336.4855     336.4855    22252.218    22252.218    3544.0411    3544.0411 
   31000     -8174.55     -8174.55   -8261.8422   -8261.8422       337.83       337.83    22313.335    22313.335   -281.81832   -281.81832 
Loop time of 32.4359 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.664 ns/day, 9.010 hours/ns, 30.830 timesteps/s
99.9% 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.871     | 31.871     | 31.871     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12835    | 0.12835    | 0.12835    |   0.0 |  0.40
Output  | 0.00015803 | 0.00015803 | 0.00015803 |   0.0 |  0.00
Modify  | 0.36929    | 0.36929    | 0.36929    |   0.0 |  1.14
Other   |            | 0.06694    |            |       |  0.21

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:      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 = 333.136527483452, Press = -3.71326931117464
next a
jump SELF top
variable a loop 2000
run 1000
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     -8174.55     -8174.55   -8261.8422   -8261.8422       337.83       337.83    22313.335    22313.335   -281.81832   -281.81832 
   32000   -8173.9172   -8173.9172   -8261.2412   -8261.2412    337.95304    337.95304        22313        22313   -212.78952   -212.78952 
Loop time of 32.5889 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.651 ns/day, 9.052 hours/ns, 30.685 timesteps/s
99.9% 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.025     | 32.025     | 32.025     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12911    | 0.12911    | 0.12911    |   0.0 |  0.40
Output  | 0.0001544  | 0.0001544  | 0.0001544  |   0.0 |  0.00
Modify  | 0.36854    | 0.36854    | 0.36854    |   0.0 |  1.13
Other   |            | 0.06643    |            |       |  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:      349382.0 ave      349382 max      349382 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349382
Ave neighs/atom = 174.69100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.14148788259, Press = 0.947023214083939
next a
jump SELF top
variable a loop 2000
run 1000
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   -8173.9172   -8173.9172   -8261.2412   -8261.2412    337.95304    337.95304        22313        22313   -212.78952   -212.78952 
   33000   -8176.3485   -8176.3485   -8262.2954   -8262.2954     332.6235     332.6235    22257.688    22257.688     3768.545     3768.545 
Loop time of 32.9527 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.622 ns/day, 9.154 hours/ns, 30.347 timesteps/s
99.9% 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.374     | 32.374     | 32.374     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13011    | 0.13011    | 0.13011    |   0.0 |  0.39
Output  | 0.00019888 | 0.00019888 | 0.00019888 |   0.0 |  0.00
Modify  | 0.38054    | 0.38054    | 0.38054    |   0.0 |  1.15
Other   |            | 0.06746    |            |       |  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:      349470.0 ave      349470 max      349470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349470
Ave neighs/atom = 174.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 = 333.259618628155, Press = -2.4486416319009
next a
jump SELF top
variable a loop 2000
run 1000
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   -8176.3485   -8176.3485   -8262.2954   -8262.2954     332.6235     332.6235    22257.688    22257.688     3768.545     3768.545 
   34000    -8173.754    -8173.754   -8259.6913   -8259.6913    332.58639    332.58639    22341.296    22341.296   -2553.4576   -2553.4576 
Loop time of 32.9892 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.619 ns/day, 9.164 hours/ns, 30.313 timesteps/s
99.9% 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.421     | 32.421     | 32.421     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12878    | 0.12878    | 0.12878    |   0.0 |  0.39
Output  | 0.00015572 | 0.00015572 | 0.00015572 |   0.0 |  0.00
Modify  | 0.37325    | 0.37325    | 0.37325    |   0.0 |  1.13
Other   |            | 0.06558    |            |       |  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:      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 = 333.319851943261, Press = -5.40923570245117
next a
jump SELF top
variable a loop 2000
run 1000
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    -8173.754    -8173.754   -8259.6913   -8259.6913    332.58639    332.58639    22341.296    22341.296   -2553.4576   -2553.4576 
   35000   -8176.7141   -8176.7141   -8263.4258   -8263.4258    335.58337    335.58337    22327.476    22327.476   -2157.6393   -2157.6393 
Loop time of 32.4337 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.664 ns/day, 9.009 hours/ns, 30.832 timesteps/s
99.9% 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.867     | 31.867     | 31.867     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12849    | 0.12849    | 0.12849    |   0.0 |  0.40
Output  | 0.00015386 | 0.00015386 | 0.00015386 |   0.0 |  0.00
Modify  | 0.37158    | 0.37158    | 0.37158    |   0.0 |  1.15
Other   |            | 0.06675    |            |       |  0.21

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:      348852.0 ave      348852 max      348852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 348852
Ave neighs/atom = 174.42600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.368250973232, Press = 2.69875991935754
next a
jump SELF top
variable a loop 2000
run 1000
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   -8176.7141   -8176.7141   -8263.4258   -8263.4258    335.58337    335.58337    22327.476    22327.476   -2157.6393   -2157.6393 
   36000   -8173.7182   -8173.7182   -8261.9126   -8261.9126    341.32148    341.32148    22287.199    22287.199    1535.9481    1535.9481 
Loop time of 33.1298 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.608 ns/day, 9.203 hours/ns, 30.184 timesteps/s
99.9% 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.552     | 32.552     | 32.552     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13062    | 0.13062    | 0.13062    |   0.0 |  0.39
Output  | 0.00015463 | 0.00015463 | 0.00015463 |   0.0 |  0.00
Modify  | 0.37979    | 0.37979    | 0.37979    |   0.0 |  1.15
Other   |            | 0.0668     |            |       |  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:      349178.0 ave      349178 max      349178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349178
Ave neighs/atom = 174.58900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.377370286404, Press = -0.902390900976926
next a
jump SELF top
variable a loop 2000
run 1000
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   -8173.7182   -8173.7182   -8261.9126   -8261.9126    341.32148    341.32148    22287.199    22287.199    1535.9481    1535.9481 
   37000   -8177.7747   -8177.7747   -8263.3524   -8263.3524    331.19432    331.19432    22298.531    22298.531   -159.69484   -159.69484 
Loop time of 32.6282 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.648 ns/day, 9.063 hours/ns, 30.648 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.062     | 32.062     | 32.062     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12815    | 0.12815    | 0.12815    |   0.0 |  0.39
Output  | 0.00015741 | 0.00015741 | 0.00015741 |   0.0 |  0.00
Modify  | 0.3721     | 0.3721     | 0.3721     |   0.0 |  1.14
Other   |            | 0.0662     |            |       |  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:      350154.0 ave      350154 max      350154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350154
Ave neighs/atom = 175.07700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.426371479654, Press = -2.33849264887636
next a
jump SELF top
variable a loop 2000
run 1000
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   -8177.7747   -8177.7747   -8263.3524   -8263.3524    331.19432    331.19432    22298.531    22298.531   -159.69484   -159.69484 
   38000   -8172.7272   -8172.7272   -8261.9526   -8261.9526    345.31178    345.31178    22316.852    22316.852   -763.39788   -763.39788 
Loop time of 32.656 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.646 ns/day, 9.071 hours/ns, 30.622 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.087     | 32.087     | 32.087     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12926    | 0.12926    | 0.12926    |   0.0 |  0.40
Output  | 0.0001586  | 0.0001586  | 0.0001586  |   0.0 |  0.00
Modify  | 0.37349    | 0.37349    | 0.37349    |   0.0 |  1.14
Other   |            | 0.06642    |            |       |  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:      349780.0 ave      349780 max      349780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349780
Ave neighs/atom = 174.89000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.484906018757, Press = -3.54964313884189
next a
jump SELF top
variable a loop 2000
run 1000
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   -8172.7272   -8172.7272   -8261.9526   -8261.9526    345.31178    345.31178    22316.852    22316.852   -763.39788   -763.39788 
   39000   -8177.3337   -8177.3337   -8264.4484   -8264.4484    337.14264    337.14264    22339.418    22339.418   -3568.7024   -3568.7024 
Loop time of 32.6365 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.647 ns/day, 9.066 hours/ns, 30.641 timesteps/s
99.9% 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.069     | 32.069     | 32.069     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12795    | 0.12795    | 0.12795    |   0.0 |  0.39
Output  | 0.00015715 | 0.00015715 | 0.00015715 |   0.0 |  0.00
Modify  | 0.37341    | 0.37341    | 0.37341    |   0.0 |  1.14
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:        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:      349554.0 ave      349554 max      349554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349554
Ave neighs/atom = 174.77700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.534528418752, Press = -3.50009068549738
next a
jump SELF top
variable a loop 2000
run 1000
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   -8177.3337   -8177.3337   -8264.4484   -8264.4484    337.14264    337.14264    22339.418    22339.418   -3568.7024   -3568.7024 
   40000   -8175.0189   -8175.0189   -8262.5476   -8262.5476    338.74542    338.74542    22301.579    22301.579   -514.59487   -514.59487 
Loop time of 32.4572 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.662 ns/day, 9.016 hours/ns, 30.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    | 31.894     | 31.894     | 31.894     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12795    | 0.12795    | 0.12795    |   0.0 |  0.39
Output  | 0.0001552  | 0.0001552  | 0.0001552  |   0.0 |  0.00
Modify  | 0.36857    | 0.36857    | 0.36857    |   0.0 |  1.14
Other   |            | 0.06605    |            |       |  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:      349174.0 ave      349174 max      349174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349174
Ave neighs/atom = 174.58700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.568726434528, Press = 1.81758975777895
next a
jump SELF top
variable a loop 2000
run 1000
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   -8175.0189   -8175.0189   -8262.5476   -8262.5476    338.74542    338.74542    22301.579    22301.579   -514.59487   -514.59487 
   41000   -8173.8555   -8173.8555   -8262.5721   -8262.5721     343.3425     343.3425    22256.261    22256.261     3679.108     3679.108 
Loop time of 32.7688 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.637 ns/day, 9.102 hours/ns, 30.517 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.199     | 32.199     | 32.199     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12967    | 0.12967    | 0.12967    |   0.0 |  0.40
Output  | 0.00015781 | 0.00015781 | 0.00015781 |   0.0 |  0.00
Modify  | 0.37281    | 0.37281    | 0.37281    |   0.0 |  1.14
Other   |            | 0.06693    |            |       |  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:      349666.0 ave      349666 max      349666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349666
Ave neighs/atom = 174.83300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.511072725529, Press = -2.68327534071585
next a
jump SELF top
variable a loop 2000
run 1000
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   -8173.8555   -8173.8555   -8262.5721   -8262.5721     343.3425     343.3425    22256.261    22256.261     3679.108     3679.108 
   42000   -8177.0882   -8177.0882   -8262.0208   -8262.0208      328.698      328.698    22327.352    22327.352   -2000.0701   -2000.0701 
Loop time of 33.2968 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.714     | 32.714     | 32.714     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13114    | 0.13114    | 0.13114    |   0.0 |  0.39
Output  | 0.00015549 | 0.00015549 | 0.00015549 |   0.0 |  0.00
Modify  | 0.38396    | 0.38396    | 0.38396    |   0.0 |  1.15
Other   |            | 0.06739    |            |       |  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:      350594.0 ave      350594 max      350594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350594
Ave neighs/atom = 175.29700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.484422929895, Press = -1.71560866274338
next a
jump SELF top
variable a loop 2000
run 1000
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   -8177.0882   -8177.0882   -8262.0208   -8262.0208      328.698      328.698    22327.352    22327.352   -2000.0701   -2000.0701 
   43000   -8173.9382   -8173.9382   -8261.6229   -8261.6229    339.34908    339.34908    22302.041    22302.041    363.39585    363.39585 
Loop time of 32.8457 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.274     | 32.274     | 32.274     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12897    | 0.12897    | 0.12897    |   0.0 |  0.39
Output  | 0.00015036 | 0.00015036 | 0.00015036 |   0.0 |  0.00
Modify  | 0.37591    | 0.37591    | 0.37591    |   0.0 |  1.14
Other   |            | 0.0668     |            |       |  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:      349168.0 ave      349168 max      349168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349168
Ave neighs/atom = 174.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 = 333.483197194308, Press = -1.03612656425501
next a
jump SELF top
variable a loop 2000
run 1000
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   -8173.9382   -8173.9382   -8261.6229   -8261.6229    339.34908    339.34908    22302.041    22302.041    363.39585    363.39585 
   44000   -8177.6694   -8177.6694   -8262.8457   -8262.8457    329.64129    329.64129    22274.845    22274.845    2028.3105    2028.3105 
Loop time of 32.2689 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.678 ns/day, 8.964 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.707     | 31.707     | 31.707     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12827    | 0.12827    | 0.12827    |   0.0 |  0.40
Output  | 0.00015724 | 0.00015724 | 0.00015724 |   0.0 |  0.00
Modify  | 0.36756    | 0.36756    | 0.36756    |   0.0 |  1.14
Other   |            | 0.06615    |            |       |  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:      349650.0 ave      349650 max      349650 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349650
Ave neighs/atom = 174.82500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.529866749941, Press = -0.716100648038537
next a
jump SELF top
variable a loop 2000
run 1000
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   -8177.6694   -8177.6694   -8262.8457   -8262.8457    329.64129    329.64129    22274.845    22274.845    2028.3105    2028.3105 
   45000   -8171.1371   -8171.1371   -8259.3926   -8259.3926    341.55806    341.55806    22325.392    22325.392   -732.13997   -732.13997 
Loop time of 32.7776 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.636 ns/day, 9.105 hours/ns, 30.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    | 32.212     | 32.212     | 32.212     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12853    | 0.12853    | 0.12853    |   0.0 |  0.39
Output  | 0.00016171 | 0.00016171 | 0.00016171 |   0.0 |  0.00
Modify  | 0.37086    | 0.37086    | 0.37086    |   0.0 |  1.13
Other   |            | 0.0663     |            |       |  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:      350328.0 ave      350328 max      350328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350328
Ave neighs/atom = 175.16400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.555638129648, Press = -3.13156467230633
next a
jump SELF top
variable a loop 2000
run 1000
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   -8171.1371   -8171.1371   -8259.3926   -8259.3926    341.55806    341.55806    22325.392    22325.392   -732.13997   -732.13997 
   46000   -8176.6414   -8176.6414   -8260.4957   -8260.4957    324.52483    324.52483    22326.256    22326.256   -1107.7567   -1107.7567 
Loop time of 33.1861 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.604 ns/day, 9.218 hours/ns, 30.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    | 32.61      | 32.61      | 32.61      |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13012    | 0.13012    | 0.13012    |   0.0 |  0.39
Output  | 0.00015196 | 0.00015196 | 0.00015196 |   0.0 |  0.00
Modify  | 0.37942    | 0.37942    | 0.37942    |   0.0 |  1.14
Other   |            | 0.06607    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5506.00 ave        5506 max        5506 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      349172.0 ave      349172 max      349172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349172
Ave neighs/atom = 174.58600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.620171430101, Press = -0.661720123426369
next a
jump SELF top
variable a loop 2000
run 1000
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   -8176.6414   -8176.6414   -8260.4957   -8260.4957    324.52483    324.52483    22326.256    22326.256   -1107.7567   -1107.7567 
   47000   -8174.3866   -8174.3866   -8261.3028   -8261.3028    336.37464    336.37464    22259.708    22259.708    3635.8156    3635.8156 
Loop time of 33.2532 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.598 ns/day, 9.237 hours/ns, 30.072 timesteps/s
99.9% 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.675     | 32.675     | 32.675     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13089    | 0.13089    | 0.13089    |   0.0 |  0.39
Output  | 0.00015697 | 0.00015697 | 0.00015697 |   0.0 |  0.00
Modify  | 0.38155    | 0.38155    | 0.38155    |   0.0 |  1.15
Other   |            | 0.06602    |            |       |  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:      349360.0 ave      349360 max      349360 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349360
Ave neighs/atom = 174.68000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.621464417443, Press = -1.22716156613054
next a
jump SELF top
variable a loop 2000
run 1000
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   -8174.3866   -8174.3866   -8261.3028   -8261.3028    336.37464    336.37464    22259.708    22259.708    3635.8156    3635.8156 
   48000   -8176.4399   -8176.4399   -8261.1967   -8261.1967    328.01776    328.01776    22330.756    22330.756   -2277.6362   -2277.6362 
Loop time of 33.1175 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.609 ns/day, 9.199 hours/ns, 30.196 timesteps/s
99.9% 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.54      | 32.54      | 32.54      |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13001    | 0.13001    | 0.13001    |   0.0 |  0.39
Output  | 0.00015413 | 0.00015413 | 0.00015413 |   0.0 |  0.00
Modify  | 0.38033    | 0.38033    | 0.38033    |   0.0 |  1.15
Other   |            | 0.06706    |            |       |  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:      350306.0 ave      350306 max      350306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350306
Ave neighs/atom = 175.15300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.609316441345, Press = -2.14600664169132
next a
jump SELF top
variable a loop 2000
run 1000
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   -8176.4399   -8176.4399   -8261.1967   -8261.1967    328.01776    328.01776    22330.756    22330.756   -2277.6362   -2277.6362 
   49000   -8180.5722   -8180.5722   -8263.2819   -8263.2819     320.0951     320.0951    22304.247    22304.247   -527.07963   -527.07963 
Loop time of 32.6119 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.649 ns/day, 9.059 hours/ns, 30.664 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.045     | 32.045     | 32.045     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12828    | 0.12828    | 0.12828    |   0.0 |  0.39
Output  | 0.0001568  | 0.0001568  | 0.0001568  |   0.0 |  0.00
Modify  | 0.3724     | 0.3724     | 0.3724     |   0.0 |  1.14
Other   |            | 0.06609    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5503.00 ave        5503 max        5503 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      349222.0 ave      349222 max      349222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349222
Ave neighs/atom = 174.61100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.566184987018, Press = -0.240368413868649
next a
jump SELF top
variable a loop 2000
run 1000
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   -8180.5722   -8180.5722   -8263.2819   -8263.2819     320.0951     320.0951    22304.247    22304.247   -527.07963   -527.07963 
   50000   -8177.8845   -8177.8845   -8263.0177   -8263.0177    329.47453    329.47453    22295.896    22295.896    271.99689    271.99689 
Loop time of 32.6781 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.644 ns/day, 9.077 hours/ns, 30.602 timesteps/s
99.9% 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.119     | 32.119     | 32.119     |   0.0 | 98.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12709    | 0.12709    | 0.12709    |   0.0 |  0.39
Output  | 0.00015607 | 0.00015607 | 0.00015607 |   0.0 |  0.00
Modify  | 0.36643    | 0.36643    | 0.36643    |   0.0 |  1.12
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:        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:      349652.0 ave      349652 max      349652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349652
Ave neighs/atom = 174.82600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.524472042463, Press = -0.488837905730413
next a
jump SELF top
variable a loop 2000
run 1000
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   -8177.8845   -8177.8845   -8263.0177   -8263.0177    329.47453    329.47453    22295.896    22295.896    271.99689    271.99689 
   51000   -8172.1136   -8172.1136   -8259.6133   -8259.6133    338.63266    338.63266    22326.457    22326.457   -1140.2138   -1140.2138 
Loop time of 32.8142 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.633 ns/day, 9.115 hours/ns, 30.475 timesteps/s
99.9% 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.242     | 32.242     | 32.242     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12964    | 0.12964    | 0.12964    |   0.0 |  0.40
Output  | 0.00019547 | 0.00019547 | 0.00019547 |   0.0 |  0.00
Modify  | 0.37535    | 0.37535    | 0.37535    |   0.0 |  1.14
Other   |            | 0.06671    |            |       |  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:      349964.0 ave      349964 max      349964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349964
Ave neighs/atom = 174.98200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.569854031368, Press = -1.84305360582939
next a
jump SELF top
variable a loop 2000
run 1000
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   -8172.1136   -8172.1136   -8259.6133   -8259.6133    338.63266    338.63266    22326.457    22326.457   -1140.2138   -1140.2138 
   52000   -8174.5526   -8174.5526   -8260.4935   -8260.4935    332.59989    332.59989    22344.509    22344.509   -2206.4625   -2206.4625 
Loop time of 32.7586 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.637 ns/day, 9.100 hours/ns, 30.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    | 32.185     | 32.185     | 32.185     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12891    | 0.12891    | 0.12891    |   0.0 |  0.39
Output  | 0.00015624 | 0.00015624 | 0.00015624 |   0.0 |  0.00
Modify  | 0.37777    | 0.37777    | 0.37777    |   0.0 |  1.15
Other   |            | 0.06692    |            |       |  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:      349168.0 ave      349168 max      349168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349168
Ave neighs/atom = 174.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 = 333.585079456572, Press = 0.404221126322188
next a
jump SELF top
variable a loop 2000
run 1000
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   -8174.5526   -8174.5526   -8260.4935   -8260.4935    332.59989    332.59989    22344.509    22344.509   -2206.4625   -2206.4625 
   53000   -8178.4949   -8178.4949   -8264.3673   -8264.3673    332.33515    332.33515    22245.197    22245.197    4102.9461    4102.9461 
Loop time of 33.3773 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.589 ns/day, 9.271 hours/ns, 29.961 timesteps/s
99.9% 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.797     | 32.797     | 32.797     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13121    | 0.13121    | 0.13121    |   0.0 |  0.39
Output  | 0.00015233 | 0.00015233 | 0.00015233 |   0.0 |  0.00
Modify  | 0.38255    | 0.38255    | 0.38255    |   0.0 |  1.15
Other   |            | 0.06613    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5510.00 ave        5510 max        5510 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      349208.0 ave      349208 max      349208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349208
Ave neighs/atom = 174.60400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.57021200471, Press = -0.257887061408335
next a
jump SELF top
variable a loop 2000
run 1000
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   -8178.4949   -8178.4949   -8264.3673   -8264.3673    332.33515    332.33515    22245.197    22245.197    4102.9461    4102.9461 
   54000   -8175.6408   -8175.6408   -8263.5041   -8263.5041    340.04015    340.04015    22323.998    22323.998    -1697.435    -1697.435 
Loop time of 32.959 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.621 ns/day, 9.155 hours/ns, 30.341 timesteps/s
99.9% 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.38      | 32.38      | 32.38      |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13021    | 0.13021    | 0.13021    |   0.0 |  0.40
Output  | 0.00015492 | 0.00015492 | 0.00015492 |   0.0 |  0.00
Modify  | 0.38192    | 0.38192    | 0.38192    |   0.0 |  1.16
Other   |            | 0.0666     |            |       |  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:      350548.0 ave      350548 max      350548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350548
Ave neighs/atom = 175.27400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.540528654468, Press = -2.17222674411466
next a
jump SELF top
variable a loop 2000
run 1000
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   -8175.6408   -8175.6408   -8263.5041   -8263.5041    340.04015    340.04015    22323.998    22323.998    -1697.435    -1697.435 
   55000   -8177.8958   -8177.8958   -8263.4224   -8263.4224     330.9968     330.9968    22316.067    22316.067   -1501.5554   -1501.5554 
Loop time of 32.6281 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.648 ns/day, 9.063 hours/ns, 30.648 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.054     | 32.054     | 32.054     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12843    | 0.12843    | 0.12843    |   0.0 |  0.39
Output  | 0.00015628 | 0.00015628 | 0.00015628 |   0.0 |  0.00
Modify  | 0.37828    | 0.37828    | 0.37828    |   0.0 |  1.16
Other   |            | 0.0671     |            |       |  0.21

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:      349454.0 ave      349454 max      349454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349454
Ave neighs/atom = 174.72700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.541510775301, Press = -0.530090617548138
next a
jump SELF top
variable a loop 2000
run 1000
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   -8177.8958   -8177.8958   -8263.4224   -8263.4224     330.9968     330.9968    22316.067    22316.067   -1501.5554   -1501.5554 
   56000   -8173.0025   -8173.0025   -8261.6532   -8261.6532    343.08728    343.08728    22302.655    22302.655    605.85927    605.85927 
Loop time of 32.8811 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.628 ns/day, 9.134 hours/ns, 30.413 timesteps/s
99.9% 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.305     | 32.305     | 32.305     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12998    | 0.12998    | 0.12998    |   0.0 |  0.40
Output  | 0.00020243 | 0.00020243 | 0.00020243 |   0.0 |  0.00
Modify  | 0.37831    | 0.37831    | 0.37831    |   0.0 |  1.15
Other   |            | 0.06716    |            |       |  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:      349604.0 ave      349604 max      349604 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349604
Ave neighs/atom = 174.80200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.589903612852, Press = -0.604181571747516
next a
jump SELF top
variable a loop 2000
run 1000
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   -8173.0025   -8173.0025   -8261.6532   -8261.6532    343.08728    343.08728    22302.655    22302.655    605.85927    605.85927 
   57000   -8176.7831   -8176.7831    -8261.547    -8261.547    328.04511    328.04511    22272.763    22272.763    2954.9495    2954.9495 
Loop time of 33.3248 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.593 ns/day, 9.257 hours/ns, 30.008 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.751     | 32.751     | 32.751     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13058    | 0.13058    | 0.13058    |   0.0 |  0.39
Output  | 0.000199   | 0.000199   | 0.000199   |   0.0 |  0.00
Modify  | 0.37732    | 0.37732    | 0.37732    |   0.0 |  1.13
Other   |            | 0.06613    |            |       |  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:      349654.0 ave      349654 max      349654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349654
Ave neighs/atom = 174.82700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.586584240006, Press = -2.65709823389261
next a
jump SELF top
variable a loop 2000
run 1000
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   -8176.7831   -8176.7831    -8261.547    -8261.547    328.04511    328.04511    22272.763    22272.763    2954.9495    2954.9495 
   58000   -8180.8635   -8180.8635   -8264.4345   -8264.4345    323.42856    323.42856    22326.719    22326.719   -3142.9481   -3142.9481 
Loop time of 33.236 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.600 ns/day, 9.232 hours/ns, 30.088 timesteps/s
99.9% 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.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12958    | 0.12958    | 0.12958    |   0.0 |  0.39
Output  | 0.00015649 | 0.00015649 | 0.00015649 |   0.0 |  0.00
Modify  | 0.3781     | 0.3781     | 0.3781     |   0.0 |  1.14
Other   |            | 0.06596    |            |       |  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:      350490.0 ave      350490 max      350490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350490
Ave neighs/atom = 175.24500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.553516650106, Press = -1.50841794404058
next a
jump SELF top
variable a loop 2000
run 1000
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   -8180.8635   -8180.8635   -8264.4345   -8264.4345    323.42856    323.42856    22326.719    22326.719   -3142.9481   -3142.9481 
   59000   -8176.4527   -8176.4527   -8260.9835   -8260.9835    327.14303    327.14303     22309.54     22309.54   -418.58171   -418.58171 
Loop time of 32.6776 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.644 ns/day, 9.077 hours/ns, 30.602 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.11      | 32.11      | 32.11      |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12856    | 0.12856    | 0.12856    |   0.0 |  0.39
Output  | 0.00015326 | 0.00015326 | 0.00015326 |   0.0 |  0.00
Modify  | 0.37293    | 0.37293    | 0.37293    |   0.0 |  1.14
Other   |            | 0.06618    |            |       |  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:      349288.0 ave      349288 max      349288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349288
Ave neighs/atom = 174.64400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.513418662883, Press = 0.24828752167461
next a
jump SELF top
variable a loop 2000
run 1000
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   -8176.4527   -8176.4527   -8260.9835   -8260.9835    327.14303    327.14303     22309.54     22309.54   -418.58171   -418.58171 
   60000   -8175.1802   -8175.1802   -8263.1222   -8263.1222    340.34486    340.34486    22274.182    22274.182    2267.3307    2267.3307 
Loop time of 32.562 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.653 ns/day, 9.045 hours/ns, 30.711 timesteps/s
99.9% 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.994     | 31.994     | 31.994     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12823    | 0.12823    | 0.12823    |   0.0 |  0.39
Output  | 0.00015376 | 0.00015376 | 0.00015376 |   0.0 |  0.00
Modify  | 0.37345    | 0.37345    | 0.37345    |   0.0 |  1.15
Other   |            | 0.06605    |            |       |  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:      349864.0 ave      349864 max      349864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349864
Ave neighs/atom = 174.93200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.496279114634, Press = -0.196660333881313
next a
jump SELF top
variable a loop 2000
run 1000
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   -8175.1802   -8175.1802   -8263.1222   -8263.1222    340.34486    340.34486    22274.182    22274.182    2267.3307    2267.3307 
   61000   -8177.5268   -8177.5268    -8260.416    -8260.416    320.78959    320.78959    22320.391    22320.391   -918.55783   -918.55783 
Loop time of 32.3336 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.672 ns/day, 8.982 hours/ns, 30.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    | 31.772     | 31.772     | 31.772     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12747    | 0.12747    | 0.12747    |   0.0 |  0.39
Output  | 0.00015431 | 0.00015431 | 0.00015431 |   0.0 |  0.00
Modify  | 0.36799    | 0.36799    | 0.36799    |   0.0 |  1.14
Other   |            | 0.06637    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5547.00 ave        5547 max        5547 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350154.0 ave      350154 max      350154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350154
Ave neighs/atom = 175.07700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.50546684182, Press = -1.3097047262874
next a
jump SELF top
variable a loop 2000
run 1000
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   -8177.5268   -8177.5268    -8260.416    -8260.416    320.78959    320.78959    22320.391    22320.391   -918.55783   -918.55783 
   62000   -8173.9877   -8173.9877   -8261.9896   -8261.9896    340.57676    340.57676    22303.572    22303.572     591.8504     591.8504 
Loop time of 33.1577 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.606 ns/day, 9.210 hours/ns, 30.159 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.579     | 32.579     | 32.579     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13051    | 0.13051    | 0.13051    |   0.0 |  0.39
Output  | 0.00015478 | 0.00015478 | 0.00015478 |   0.0 |  0.00
Modify  | 0.38109    | 0.38109    | 0.38109    |   0.0 |  1.15
Other   |            | 0.06681    |            |       |  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:      349428.0 ave      349428 max      349428 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349428
Ave neighs/atom = 174.71400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.528842460486, Press = -0.626364550588043
next a
jump SELF top
variable a loop 2000
run 1000
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   -8173.9877   -8173.9877   -8261.9896   -8261.9896    340.57676    340.57676    22303.572    22303.572     591.8504     591.8504 
   63000   -8178.3922   -8178.3922   -8265.7202   -8265.7202    337.96843    337.96843    22250.481    22250.481    3153.6405    3153.6405 
Loop time of 33.6389 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.568 ns/day, 9.344 hours/ns, 29.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    | 33.049     | 33.049     | 33.049     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13181    | 0.13181    | 0.13181    |   0.0 |  0.39
Output  | 0.00015534 | 0.00015534 | 0.00015534 |   0.0 |  0.00
Modify  | 0.39041    | 0.39041    | 0.39041    |   0.0 |  1.16
Other   |            | 0.06723    |            |       |  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:      349690.0 ave      349690 max      349690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349690
Ave neighs/atom = 174.84500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.51795143518, Press = -1.32456190865113
next a
jump SELF top
variable a loop 2000
run 1000
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   -8178.3922   -8178.3922   -8265.7202   -8265.7202    337.96843    337.96843    22250.481    22250.481    3153.6405    3153.6405 
   64000   -8174.8661   -8174.8661   -8261.3483   -8261.3483    334.69521    334.69521    22364.264    22364.264   -4482.2782   -4482.2782 
Loop time of 32.9454 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.372     | 32.372     | 32.372     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12886    | 0.12886    | 0.12886    |   0.0 |  0.39
Output  | 0.00015651 | 0.00015651 | 0.00015651 |   0.0 |  0.00
Modify  | 0.37786    | 0.37786    | 0.37786    |   0.0 |  1.15
Other   |            | 0.06684    |            |       |  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:      350058.0 ave      350058 max      350058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350058
Ave neighs/atom = 175.02900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.481293699333, Press = -2.7487763640853
next a
jump SELF top
variable a loop 2000
run 1000
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   -8174.8661   -8174.8661   -8261.3483   -8261.3483    334.69521    334.69521    22364.264    22364.264   -4482.2782   -4482.2782 
   65000    -8177.291    -8177.291   -8263.1727   -8263.1727    332.37141    332.37141    22302.207    22302.207    -219.4802    -219.4802 
Loop time of 32.958 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.622 ns/day, 9.155 hours/ns, 30.342 timesteps/s
99.9% 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.379     | 32.379     | 32.379     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13024    | 0.13024    | 0.13024    |   0.0 |  0.40
Output  | 0.00015482 | 0.00015482 | 0.00015482 |   0.0 |  0.00
Modify  | 0.38097    | 0.38097    | 0.38097    |   0.0 |  1.16
Other   |            | 0.06741    |            |       |  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:      348668.0 ave      348668 max      348668 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 348668
Ave neighs/atom = 174.33400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.441361590259, Press = 0.471585256427435
next a
jump SELF top
variable a loop 2000
run 1000
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    -8177.291    -8177.291   -8263.1727   -8263.1727    332.37141    332.37141    22302.207    22302.207    -219.4802    -219.4802 
   66000   -8180.8312   -8180.8312   -8265.4749   -8265.4749    327.57982    327.57982    22277.162    22277.162    1144.0936    1144.0936 
Loop time of 33.0365 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.615 ns/day, 9.177 hours/ns, 30.270 timesteps/s
99.9% 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.463     | 32.463     | 32.463     |   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.00015747 | 0.00015747 | 0.00015747 |   0.0 |  0.00
Modify  | 0.37757    | 0.37757    | 0.37757    |   0.0 |  1.14
Other   |            | 0.06616    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5548.00 ave        5548 max        5548 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      349276.0 ave      349276 max      349276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349276
Ave neighs/atom = 174.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 = 333.431084075148, Press = -0.162041811170174
next a
jump SELF top
variable a loop 2000
run 1000
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   -8180.8312   -8180.8312   -8265.4749   -8265.4749    327.57982    327.57982    22277.162    22277.162    1144.0936    1144.0936 
   67000   -8175.5039   -8175.5039   -8261.2532   -8261.2532     331.8588     331.8588    22325.659    22325.659   -1417.4591   -1417.4591 
Loop time of 32.1051 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.691 ns/day, 8.918 hours/ns, 31.148 timesteps/s
99.9% 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.548     | 31.548     | 31.548     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12678    | 0.12678    | 0.12678    |   0.0 |  0.39
Output  | 0.00015579 | 0.00015579 | 0.00015579 |   0.0 |  0.00
Modify  | 0.36429    | 0.36429    | 0.36429    |   0.0 |  1.13
Other   |            | 0.0661     |            |       |  0.21

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:      350144.0 ave      350144 max      350144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350144
Ave neighs/atom = 175.07200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.3886503921, Press = -1.07812629387065
next a
jump SELF top
variable a loop 2000
run 1000
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   -8175.5039   -8175.5039   -8261.2532   -8261.2532     331.8588     331.8588    22325.659    22325.659   -1417.4591   -1417.4591 
   68000   -8177.4201   -8177.4201   -8264.5283   -8264.5283    337.11737    337.11737     22335.02     22335.02   -3740.1261   -3740.1261 
Loop time of 31.7306 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.723 ns/day, 8.814 hours/ns, 31.515 timesteps/s
99.9% 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.18      | 31.18      | 31.18      |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12501    | 0.12501    | 0.12501    |   0.0 |  0.39
Output  | 0.00020126 | 0.00020126 | 0.00020126 |   0.0 |  0.00
Modify  | 0.35931    | 0.35931    | 0.35931    |   0.0 |  1.13
Other   |            | 0.06596    |            |       |  0.21

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:      349068.0 ave      349068 max      349068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349068
Ave neighs/atom = 174.53400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.409384680802, Press = 0.568052647758215
next a
jump SELF top
variable a loop 2000
run 1000
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   -8177.4201   -8177.4201   -8264.5283   -8264.5283    337.11737    337.11737     22335.02     22335.02   -3740.1261   -3740.1261 
   69000   -8173.7621   -8173.7621    -8261.136    -8261.136    338.14596    338.14596    22293.439    22293.439    1491.5717    1491.5717 
Loop time of 32.2913 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.676 ns/day, 8.970 hours/ns, 30.968 timesteps/s
99.9% 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.726     | 31.726     | 31.726     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12776    | 0.12776    | 0.12776    |   0.0 |  0.40
Output  | 0.00015731 | 0.00015731 | 0.00015731 |   0.0 |  0.00
Modify  | 0.3711     | 0.3711     | 0.3711     |   0.0 |  1.15
Other   |            | 0.06653    |            |       |  0.21

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:      349280.0 ave      349280 max      349280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349280
Ave neighs/atom = 174.64000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.437436376441, Press = -0.068140578799939
next a
jump SELF top
variable a loop 2000
run 1000
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   -8173.7621   -8173.7621    -8261.136    -8261.136    338.14596    338.14596    22293.439    22293.439    1491.5717    1491.5717 
   70000   -8177.9295   -8177.9295   -8262.1986   -8262.1986    326.13015    326.13015    22288.427    22288.427    1108.5078    1108.5078 
Loop time of 32.1606 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.6       | 31.6       | 31.6       |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12682    | 0.12682    | 0.12682    |   0.0 |  0.39
Output  | 0.00020697 | 0.00020697 | 0.00020697 |   0.0 |  0.00
Modify  | 0.36755    | 0.36755    | 0.36755    |   0.0 |  1.14
Other   |            | 0.06624    |            |       |  0.21

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:      350146.0 ave      350146 max      350146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350146
Ave neighs/atom = 175.07300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.465323482087, Press = -0.716863501109295
next a
jump SELF top
variable a loop 2000
run 1000
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   -8177.9295   -8177.9295   -8262.1986   -8262.1986    326.13015    326.13015    22288.427    22288.427    1108.5078    1108.5078 
   71000   -8174.2304   -8174.2304     -8261.51     -8261.51    337.78069    337.78069     22319.86     22319.86   -673.43801   -673.43801 
Loop time of 32.0296 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.698 ns/day, 8.897 hours/ns, 31.221 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.472     | 31.472     | 31.472     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12631    | 0.12631    | 0.12631    |   0.0 |  0.39
Output  | 0.00015506 | 0.00015506 | 0.00015506 |   0.0 |  0.00
Modify  | 0.36516    | 0.36516    | 0.36516    |   0.0 |  1.14
Other   |            | 0.06602    |            |       |  0.21

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:      349936.0 ave      349936 max      349936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349936
Ave neighs/atom = 174.96800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.44312121775, Press = -0.323012869168173
next a
jump SELF top
variable a loop 2000
run 1000
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   -8174.2304   -8174.2304     -8261.51     -8261.51    337.78069    337.78069     22319.86     22319.86   -673.43801   -673.43801 
   72000    -8182.229    -8182.229   -8264.7631   -8264.7631    319.41537    319.41537    22273.679    22273.679    1300.3531    1300.3531 
Loop time of 32.4495 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.879     | 31.879     | 31.879     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13035    | 0.13035    | 0.13035    |   0.0 |  0.40
Output  | 0.00015777 | 0.00015777 | 0.00015777 |   0.0 |  0.00
Modify  | 0.37367    | 0.37367    | 0.37367    |   0.0 |  1.15
Other   |            | 0.06652    |            |       |  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:      349332.0 ave      349332 max      349332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349332
Ave neighs/atom = 174.66600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.417631307608, Press = 0.61322209084201
next a
jump SELF top
variable a loop 2000
run 1000
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    -8182.229    -8182.229   -8264.7631   -8264.7631    319.41537    319.41537    22273.679    22273.679    1300.3531    1300.3531 
   73000   -8174.3282   -8174.3282   -8260.8959   -8260.8959    335.02572    335.02572    22288.338    22288.338    1321.2259    1321.2259 
Loop time of 32.2787 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.677 ns/day, 8.966 hours/ns, 30.980 timesteps/s
99.9% 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.715     | 31.715     | 31.715     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12762    | 0.12762    | 0.12762    |   0.0 |  0.40
Output  | 0.00015445 | 0.00015445 | 0.00015445 |   0.0 |  0.00
Modify  | 0.36964    | 0.36964    | 0.36964    |   0.0 |  1.15
Other   |            | 0.0664     |            |       |  0.21

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:      349982.0 ave      349982 max      349982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349982
Ave neighs/atom = 174.99100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.389844121981, Press = -1.82939533779127
next a
jump SELF top
variable a loop 2000
run 1000
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   -8174.3282   -8174.3282   -8260.8959   -8260.8959    335.02572    335.02572    22288.338    22288.338    1321.2259    1321.2259 
   74000   -8174.0163   -8174.0163   -8259.6415   -8259.6415     331.3784     331.3784    22348.239    22348.239   -2895.8895   -2895.8895 
Loop time of 33.562 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.574 ns/day, 9.323 hours/ns, 29.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    | 32.968     | 32.968     | 32.968     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1328     | 0.1328     | 0.1328     |   0.0 |  0.40
Output  | 0.00044382 | 0.00044382 | 0.00044382 |   0.0 |  0.00
Modify  | 0.39284    | 0.39284    | 0.39284    |   0.0 |  1.17
Other   |            | 0.0676     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5516.00 ave        5516 max        5516 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      350006.0 ave      350006 max      350006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 350006
Ave neighs/atom = 175.00300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.366110026262, Press = 0.0728402319276935
next a
jump SELF top
variable a loop 2000
run 1000
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   -8174.0163   -8174.0163   -8259.6415   -8259.6415     331.3784     331.3784    22348.239    22348.239   -2895.8895   -2895.8895 
   75000   -8174.4502   -8174.4502   -8261.1662   -8261.1662     335.5997     335.5997    22297.346    22297.346     977.4646     977.4646 
Loop time of 33.1499 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.606 ns/day, 9.208 hours/ns, 30.166 timesteps/s
99.9% 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.571     | 32.571     | 32.571     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13101    | 0.13101    | 0.13101    |   0.0 |  0.40
Output  | 0.00015339 | 0.00015339 | 0.00015339 |   0.0 |  0.00
Modify  | 0.38206    | 0.38206    | 0.38206    |   0.0 |  1.15
Other   |            | 0.06621    |            |       |  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:      349144.0 ave      349144 max      349144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349144
Ave neighs/atom = 174.57200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.364788361003, Press = 0.752925242082145
next a
jump SELF top
variable a loop 2000
run 1000
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   -8174.4502   -8174.4502   -8261.1662   -8261.1662     335.5997     335.5997    22297.346    22297.346     977.4646     977.4646 
   76000   -8176.4499   -8176.4499   -8261.5614   -8261.5614    329.39039    329.39039    22281.341    22281.341    1835.2977    1835.2977 
Loop time of 33.3888 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.803     | 32.803     | 32.803     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13155    | 0.13155    | 0.13155    |   0.0 |  0.39
Output  | 0.00015172 | 0.00015172 | 0.00015172 |   0.0 |  0.00
Modify  | 0.38645    | 0.38645    | 0.38645    |   0.0 |  1.16
Other   |            | 0.0673     |            |       |  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:      349708.0 ave      349708 max      349708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 349708
Ave neighs/atom = 174.85400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
22304.2026063415

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0