# 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 3.5090000331401834*${_u_distance}
variable latticeconst_converted equal 3.5090000331401834*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.50900003314018
Lattice spacing in x,y,z = 3.5090000 3.5090000 3.5090000
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 (35.090000 35.090000 35.090000)
  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 (35.090000 35.090000 35.090000)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Li

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

kim interactions Li
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_RoyDuttaChakraborti_2021_AlLi__MO_971738391444_000
pair_coeff * * Li
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 6.941

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43206.6024531732 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.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_971738391444_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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -3224.2527   -3224.2527        -3300        -3300       293.15       293.15    43206.602    43206.602     1872.559     1872.559 
    1000   -3202.3371   -3202.3371   -3278.1856   -3278.1856    293.54162    293.54162    47095.873    47095.873    449.02295    449.02295 
Loop time of 91.515 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.944 ns/day, 25.421 hours/ns, 10.927 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 90.514     | 90.514     | 90.514     |   0.0 | 98.91
Neigh   | 0.5059     | 0.5059     | 0.5059     |   0.0 |  0.55
Comm    | 0.089952   | 0.089952   | 0.089952   |   0.0 |  0.10
Output  | 0.00022429 | 0.00022429 | 0.00022429 |   0.0 |  0.00
Modify  | 0.34996    | 0.34996    | 0.34996    |   0.0 |  0.38
Other   |            | 0.05483    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3308.00 ave        3308 max        3308 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119276.0 ave      119276 max      119276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119276
Ave neighs/atom = 59.638000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -3202.3371   -3202.3371   -3278.1856   -3278.1856    293.54162    293.54162    47095.873    47095.873    449.02295    449.02295 
    2000   -3200.4666   -3200.4666   -3277.2026   -3277.2026    296.97614    296.97614    47313.629    47313.629    32.483994    32.483994 
Loop time of 93.1904 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.927 ns/day, 25.886 hours/ns, 10.731 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 92.175     | 92.175     | 92.175     |   0.0 | 98.91
Neigh   | 0.50797    | 0.50797    | 0.50797    |   0.0 |  0.55
Comm    | 0.093008   | 0.093008   | 0.093008   |   0.0 |  0.10
Output  | 0.00018668 | 0.00018668 | 0.00018668 |   0.0 |  0.00
Modify  | 0.35725    | 0.35725    | 0.35725    |   0.0 |  0.38
Other   |            | 0.05653    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3294.00 ave        3294 max        3294 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119472.0 ave      119472 max      119472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119472
Ave neighs/atom = 59.736000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -3200.4666   -3200.4666   -3277.2026   -3277.2026    296.97614    296.97614    47313.629    47313.629    32.483994    32.483994 
    3000   -3199.6129   -3199.6129   -3277.6928   -3277.6928    302.17721    302.17721    47342.911    47342.911   -104.49734   -104.49734 
Loop time of 94.6911 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.912 ns/day, 26.303 hours/ns, 10.561 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 93.664     | 93.664     | 93.664     |   0.0 | 98.92
Neigh   | 0.50782    | 0.50782    | 0.50782    |   0.0 |  0.54
Comm    | 0.093934   | 0.093934   | 0.093934   |   0.0 |  0.10
Output  | 0.00023678 | 0.00023678 | 0.00023678 |   0.0 |  0.00
Modify  | 0.36732    | 0.36732    | 0.36732    |   0.0 |  0.39
Other   |            | 0.05748    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3293.00 ave        3293 max        3293 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119484.0 ave      119484 max      119484 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119484
Ave neighs/atom = 59.742000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -3199.6129   -3199.6129   -3277.6928   -3277.6928    302.17721    302.17721    47342.911    47342.911   -104.49734   -104.49734 
    4000   -3202.9796   -3202.9796   -3279.0369   -3279.0369    294.34982    294.34982    47302.326    47302.326   -128.46782   -128.46782 
Loop time of 93.5612 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.923 ns/day, 25.989 hours/ns, 10.688 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 92.566     | 92.566     | 92.566     |   0.0 | 98.94
Neigh   | 0.4795     | 0.4795     | 0.4795     |   0.0 |  0.51
Comm    | 0.092281   | 0.092281   | 0.092281   |   0.0 |  0.10
Output  | 0.00019118 | 0.00019118 | 0.00019118 |   0.0 |  0.00
Modify  | 0.36606    | 0.36606    | 0.36606    |   0.0 |  0.39
Other   |            | 0.05732    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3226.00 ave        3226 max        3226 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119368.0 ave      119368 max      119368 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119368
Ave neighs/atom = 59.684000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -3202.9796   -3202.9796   -3279.0369   -3279.0369    294.34982    294.34982    47302.326    47302.326   -128.46782   -128.46782 
    5000   -3200.9302   -3200.9302   -3275.5009   -3275.5009    288.59625    288.59625    47375.849    47375.849   -210.96775   -210.96775 
Loop time of 96.5984 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.833 hours/ns, 10.352 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.591     | 95.591     | 95.591     |   0.0 | 98.96
Neigh   | 0.47952    | 0.47952    | 0.47952    |   0.0 |  0.50
Comm    | 0.093516   | 0.093516   | 0.093516   |   0.0 |  0.10
Output  | 0.00015763 | 0.00015763 | 0.00015763 |   0.0 |  0.00
Modify  | 0.37618    | 0.37618    | 0.37618    |   0.0 |  0.39
Other   |            | 0.05786    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3290.00 ave        3290 max        3290 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119392.0 ave      119392 max      119392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119392
Ave neighs/atom = 59.696000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 296.346284630945, Press = -51.901646054558
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -3200.9302   -3200.9302   -3275.5009   -3275.5009    288.59625    288.59625    47375.849    47375.849   -210.96775   -210.96775 
    6000   -3200.7219   -3200.7219   -3275.3911   -3275.3911    288.97738    288.97738    47569.533    47569.533   -698.96435   -698.96435 
Loop time of 94.747 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.912 ns/day, 26.319 hours/ns, 10.554 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 93.721     | 93.721     | 93.721     |   0.0 | 98.92
Neigh   | 0.49458    | 0.49458    | 0.49458    |   0.0 |  0.52
Comm    | 0.092407   | 0.092407   | 0.092407   |   0.0 |  0.10
Output  | 0.00015318 | 0.00015318 | 0.00015318 |   0.0 |  0.00
Modify  | 0.38229    | 0.38229    | 0.38229    |   0.0 |  0.40
Other   |            | 0.0569     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3291.00 ave        3291 max        3291 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119066.0 ave      119066 max      119066 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119066
Ave neighs/atom = 59.533000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.888189020381, Press = 2.01113354145865
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -3200.7219   -3200.7219   -3275.3911   -3275.3911    288.97738    288.97738    47569.533    47569.533   -698.96435   -698.96435 
    7000   -3202.6891   -3202.6891   -3277.1922   -3277.1922    288.33494    288.33494    47254.945    47254.945    213.07637    213.07637 
Loop time of 94.6845 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.913 ns/day, 26.301 hours/ns, 10.561 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 93.654     | 93.654     | 93.654     |   0.0 | 98.91
Neigh   | 0.49631    | 0.49631    | 0.49631    |   0.0 |  0.52
Comm    | 0.093211   | 0.093211   | 0.093211   |   0.0 |  0.10
Output  | 0.00015619 | 0.00015619 | 0.00015619 |   0.0 |  0.00
Modify  | 0.38364    | 0.38364    | 0.38364    |   0.0 |  0.41
Other   |            | 0.0571     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3291.00 ave        3291 max        3291 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119418.0 ave      119418 max      119418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119418
Ave neighs/atom = 59.709000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 294.934799675662, Press = -22.7970572538237
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -3202.6891   -3202.6891   -3277.1922   -3277.1922    288.33494    288.33494    47254.945    47254.945    213.07637    213.07637 
    8000   -3202.5094   -3202.5094   -3281.4425   -3281.4425    305.47907    305.47907    47225.478    47225.478    395.21077    395.21077 
Loop time of 95.2832 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.907 ns/day, 26.468 hours/ns, 10.495 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.258     | 94.258     | 94.258     |   0.0 | 98.92
Neigh   | 0.49498    | 0.49498    | 0.49498    |   0.0 |  0.52
Comm    | 0.093234   | 0.093234   | 0.093234   |   0.0 |  0.10
Output  | 0.00018462 | 0.00018462 | 0.00018462 |   0.0 |  0.00
Modify  | 0.37962    | 0.37962    | 0.37962    |   0.0 |  0.40
Other   |            | 0.05671    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3289.00 ave        3289 max        3289 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119526.0 ave      119526 max      119526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119526
Ave neighs/atom = 59.763000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 294.413571809075, Press = -1.36887566721392
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -3202.5094   -3202.5094   -3281.4425   -3281.4425    305.47907    305.47907    47225.478    47225.478    395.21077    395.21077 
    9000   -3206.3504   -3206.3504   -3281.1898   -3281.1898    289.63593    289.63593    47401.632    47401.632   -167.05758   -167.05758 
Loop time of 97.0569 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.890 ns/day, 26.960 hours/ns, 10.303 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.015     | 96.015     | 96.015     |   0.0 | 98.93
Neigh   | 0.50016    | 0.50016    | 0.50016    |   0.0 |  0.52
Comm    | 0.095035   | 0.095035   | 0.095035   |   0.0 |  0.10
Output  | 0.00015582 | 0.00015582 | 0.00015582 |   0.0 |  0.00
Modify  | 0.38906    | 0.38906    | 0.38906    |   0.0 |  0.40
Other   |            | 0.0571     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3315.00 ave        3315 max        3315 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119338.0 ave      119338 max      119338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119338
Ave neighs/atom = 59.669000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 294.553777231247, Press = 3.50677391028385
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -3206.3504   -3206.3504   -3281.1898   -3281.1898    289.63593    289.63593    47401.632    47401.632   -167.05758   -167.05758 
   10000   -3209.8928   -3209.8928   -3283.6661   -3283.6661    285.51008    285.51008    47391.168    47391.168   -129.17377   -129.17377 
Loop time of 96.4295 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.786 hours/ns, 10.370 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.392     | 95.392     | 95.392     |   0.0 | 98.92
Neigh   | 0.49911    | 0.49911    | 0.49911    |   0.0 |  0.52
Comm    | 0.094464   | 0.094464   | 0.094464   |   0.0 |  0.10
Output  | 0.0001861  | 0.0001861  | 0.0001861  |   0.0 |  0.00
Modify  | 0.38666    | 0.38666    | 0.38666    |   0.0 |  0.40
Other   |            | 0.05712    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3322.00 ave        3322 max        3322 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119280.0 ave      119280 max      119280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119280
Ave neighs/atom = 59.640000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.784043563907, Press = 2.48567143499735
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -3209.8928   -3209.8928   -3283.6661   -3283.6661    285.51008    285.51008    47391.168    47391.168   -129.17377   -129.17377 
   11000   -3208.4967   -3208.4967    -3282.947    -3282.947    288.13023    288.13023    47491.741    47491.741   -278.90505   -278.90505 
Loop time of 99.456 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.869 ns/day, 27.627 hours/ns, 10.055 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.418     | 98.418     | 98.418     |   0.0 | 98.96
Neigh   | 0.48138    | 0.48138    | 0.48138    |   0.0 |  0.48
Comm    | 0.095144   | 0.095144   | 0.095144   |   0.0 |  0.10
Output  | 0.00020076 | 0.00020076 | 0.00020076 |   0.0 |  0.00
Modify  | 0.40276    | 0.40276    | 0.40276    |   0.0 |  0.40
Other   |            | 0.05828    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3307.00 ave        3307 max        3307 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      118810.0 ave      118810 max      118810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118810
Ave neighs/atom = 59.405000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.466602718272, Press = -2.60606040279637
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -3208.4967   -3208.4967    -3282.947    -3282.947    288.13023    288.13023    47491.741    47491.741   -278.90505   -278.90505 
   12000   -3204.2803   -3204.2803   -3280.9696   -3280.9696     296.7957     296.7957    47365.437    47365.437    29.445714    29.445714 
Loop time of 96.4306 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.786 hours/ns, 10.370 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.376     | 95.376     | 95.376     |   0.0 | 98.91
Neigh   | 0.51806    | 0.51806    | 0.51806    |   0.0 |  0.54
Comm    | 0.094363   | 0.094363   | 0.094363   |   0.0 |  0.10
Output  | 0.00015479 | 0.00015479 | 0.00015479 |   0.0 |  0.00
Modify  | 0.38538    | 0.38538    | 0.38538    |   0.0 |  0.40
Other   |            | 0.05686    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3328.00 ave        3328 max        3328 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119122.0 ave      119122 max      119122 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119122
Ave neighs/atom = 59.561000
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.605833195516, Press = -5.31465896472196
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -3204.2803   -3204.2803   -3280.9696   -3280.9696     296.7957     296.7957    47365.437    47365.437    29.445714    29.445714 
   13000   -3205.2684   -3205.2684   -3281.7816   -3281.7816    296.11401    296.11401    47234.346    47234.346     272.0725     272.0725 
Loop time of 95.9135 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.643 hours/ns, 10.426 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.882     | 94.882     | 94.882     |   0.0 | 98.92
Neigh   | 0.49585    | 0.49585    | 0.49585    |   0.0 |  0.52
Comm    | 0.094183   | 0.094183   | 0.094183   |   0.0 |  0.10
Output  | 0.00015561 | 0.00015561 | 0.00015561 |   0.0 |  0.00
Modify  | 0.3837     | 0.3837     | 0.3837     |   0.0 |  0.40
Other   |            | 0.05744    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3327.00 ave        3327 max        3327 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119334.0 ave      119334 max      119334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119334
Ave neighs/atom = 59.667000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.586646057192, Press = -2.90866383497631
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -3205.2684   -3205.2684   -3281.7816   -3281.7816    296.11401    296.11401    47234.346    47234.346     272.0725     272.0725 
   14000   -3201.8815   -3201.8815    -3280.135    -3280.135    302.84888    302.84888     47263.62     47263.62    333.70392    333.70392 
Loop time of 98.4544 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.348 hours/ns, 10.157 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.405     | 97.405     | 97.405     |   0.0 | 98.93
Neigh   | 0.49874    | 0.49874    | 0.49874    |   0.0 |  0.51
Comm    | 0.096288   | 0.096288   | 0.096288   |   0.0 |  0.10
Output  | 0.00018736 | 0.00018736 | 0.00018736 |   0.0 |  0.00
Modify  | 0.39669    | 0.39669    | 0.39669    |   0.0 |  0.40
Other   |            | 0.05738    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3339.00 ave        3339 max        3339 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119586.0 ave      119586 max      119586 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119586
Ave neighs/atom = 59.793000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.765762793491, Press = 2.12774305480541
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -3201.8815   -3201.8815    -3280.135    -3280.135    302.84888    302.84888     47263.62     47263.62    333.70392    333.70392 
   15000   -3206.7324   -3206.7324   -3282.4186   -3282.4186    292.91325    292.91325    47524.833    47524.833    -349.5421    -349.5421 
Loop time of 97.4563 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.887 ns/day, 27.071 hours/ns, 10.261 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.413     | 96.413     | 96.413     |   0.0 | 98.93
Neigh   | 0.49806    | 0.49806    | 0.49806    |   0.0 |  0.51
Comm    | 0.095212   | 0.095212   | 0.095212   |   0.0 |  0.10
Output  | 0.00015339 | 0.00015339 | 0.00015339 |   0.0 |  0.00
Modify  | 0.39288    | 0.39288    | 0.39288    |   0.0 |  0.40
Other   |            | 0.05734    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3283.00 ave        3283 max        3283 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119138.0 ave      119138 max      119138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119138
Ave neighs/atom = 59.569000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.71614366027, Press = 1.74572215391031
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -3206.7324   -3206.7324   -3282.4186   -3282.4186    292.91325    292.91325    47524.833    47524.833    -349.5421    -349.5421 
   16000   -3210.9013   -3210.9013   -3284.8508   -3284.8508    286.19249    286.19249    47409.784    47409.784   -264.06409   -264.06409 
Loop time of 97.1397 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.889 ns/day, 26.983 hours/ns, 10.294 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.097     | 96.097     | 96.097     |   0.0 | 98.93
Neigh   | 0.49703    | 0.49703    | 0.49703    |   0.0 |  0.51
Comm    | 0.094605   | 0.094605   | 0.094605   |   0.0 |  0.10
Output  | 0.00015056 | 0.00015056 | 0.00015056 |   0.0 |  0.00
Modify  | 0.39342    | 0.39342    | 0.39342    |   0.0 |  0.41
Other   |            | 0.05757    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3306.00 ave        3306 max        3306 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119010.0 ave      119010 max      119010 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119010
Ave neighs/atom = 59.505000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.592578860071, Press = -2.36546790593108
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -3210.9013   -3210.9013   -3284.8508   -3284.8508    286.19249    286.19249    47409.784    47409.784   -264.06409   -264.06409 
   17000   -3206.1342   -3206.1342   -3282.6246   -3282.6246    296.02577    296.02577    47318.307    47318.307    104.34122    104.34122 
Loop time of 95.9399 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.650 hours/ns, 10.423 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.937     | 94.937     | 94.937     |   0.0 | 98.95
Neigh   | 0.46967    | 0.46967    | 0.46967    |   0.0 |  0.49
Comm    | 0.094029   | 0.094029   | 0.094029   |   0.0 |  0.10
Output  | 0.00015524 | 0.00015524 | 0.00015524 |   0.0 |  0.00
Modify  | 0.38237    | 0.38237    | 0.38237    |   0.0 |  0.40
Other   |            | 0.05669    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3344.00 ave        3344 max        3344 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119206.0 ave      119206 max      119206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119206
Ave neighs/atom = 59.603000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.390325776574, Press = -3.40358459223855
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -3206.1342   -3206.1342   -3282.6246   -3282.6246    296.02577    296.02577    47318.307    47318.307    104.34122    104.34122 
   18000   -3206.9729   -3206.9729   -3282.7082   -3282.7082    293.10357    293.10357    47043.767    47043.767    594.04987    594.04987 
Loop time of 97.6672 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.885 ns/day, 27.130 hours/ns, 10.239 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.63      | 96.63      | 96.63      |   0.0 | 98.94
Neigh   | 0.49076    | 0.49076    | 0.49076    |   0.0 |  0.50
Comm    | 0.095434   | 0.095434   | 0.095434   |   0.0 |  0.10
Output  | 0.00018972 | 0.00018972 | 0.00018972 |   0.0 |  0.00
Modify  | 0.39299    | 0.39299    | 0.39299    |   0.0 |  0.40
Other   |            | 0.05815    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3291.00 ave        3291 max        3291 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119934.0 ave      119934 max      119934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119934
Ave neighs/atom = 59.967000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.25963764217, Press = 1.23296861060754
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -3206.9729   -3206.9729   -3282.7082   -3282.7082    293.10357    293.10357    47043.767    47043.767    594.04987    594.04987 
   19000   -3207.3329   -3207.3329   -3283.2113   -3283.2113     293.6571     293.6571    47248.976    47248.976    188.11089    188.11089 
Loop time of 96.1016 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.695 hours/ns, 10.406 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.053     | 95.053     | 95.053     |   0.0 | 98.91
Neigh   | 0.51454    | 0.51454    | 0.51454    |   0.0 |  0.54
Comm    | 0.094027   | 0.094027   | 0.094027   |   0.0 |  0.10
Output  | 0.00015647 | 0.00015647 | 0.00015647 |   0.0 |  0.00
Modify  | 0.38333    | 0.38333    | 0.38333    |   0.0 |  0.40
Other   |            | 0.0565     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3314.00 ave        3314 max        3314 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119636.0 ave      119636 max      119636 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119636
Ave neighs/atom = 59.818000
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.306493843464, Press = 1.01437555244582
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -3207.3329   -3207.3329   -3283.2113   -3283.2113     293.6571     293.6571    47248.976    47248.976    188.11089    188.11089 
   20000   -3202.9956   -3202.9956   -3278.7847   -3278.7847    293.31163    293.31163    47440.509    47440.509   -122.58619   -122.58619 
Loop time of 97.3442 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.888 ns/day, 27.040 hours/ns, 10.273 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.305     | 96.305     | 96.305     |   0.0 | 98.93
Neigh   | 0.4986     | 0.4986     | 0.4986     |   0.0 |  0.51
Comm    | 0.095293   | 0.095293   | 0.095293   |   0.0 |  0.10
Output  | 0.00015604 | 0.00015604 | 0.00015604 |   0.0 |  0.00
Modify  | 0.38838    | 0.38838    | 0.38838    |   0.0 |  0.40
Other   |            | 0.05711    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3325.00 ave        3325 max        3325 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119488.0 ave      119488 max      119488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119488
Ave neighs/atom = 59.744000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.398950325743, Press = 0.0138191293125696
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -3202.9956   -3202.9956   -3278.7847   -3278.7847    293.31163    293.31163    47440.509    47440.509   -122.58619   -122.58619 
   21000     -3208.13     -3208.13   -3283.9066   -3283.9066    293.26313    293.26313    47273.848    47273.848    188.25409    188.25409 
Loop time of 94.826 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.911 ns/day, 26.341 hours/ns, 10.546 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 93.838     | 93.838     | 93.838     |   0.0 | 98.96
Neigh   | 0.46214    | 0.46214    | 0.46214    |   0.0 |  0.49
Comm    | 0.091849   | 0.091849   | 0.091849   |   0.0 |  0.10
Output  | 0.00015884 | 0.00015884 | 0.00015884 |   0.0 |  0.00
Modify  | 0.37729    | 0.37729    | 0.37729    |   0.0 |  0.40
Other   |            | 0.05664    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3326.00 ave        3326 max        3326 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119572.0 ave      119572 max      119572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119572
Ave neighs/atom = 59.786000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.502638769302, Press = 0.656193823717797
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000     -3208.13     -3208.13   -3283.9066   -3283.9066    293.26313    293.26313    47273.848    47273.848    188.25409    188.25409 
   22000    -3207.482    -3207.482   -3282.6523   -3282.6523    290.91701    290.91701    47525.084    47525.084   -456.08892   -456.08892 
Loop time of 97.7144 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.884 ns/day, 27.143 hours/ns, 10.234 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.673     | 96.673     | 96.673     |   0.0 | 98.93
Neigh   | 0.49781    | 0.49781    | 0.49781    |   0.0 |  0.51
Comm    | 0.09452    | 0.09452    | 0.09452    |   0.0 |  0.10
Output  | 0.00016814 | 0.00016814 | 0.00016814 |   0.0 |  0.00
Modify  | 0.39146    | 0.39146    | 0.39146    |   0.0 |  0.40
Other   |            | 0.05711    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3320.00 ave        3320 max        3320 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119064.0 ave      119064 max      119064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119064
Ave neighs/atom = 59.532000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.462818151564, Press = 0.269954982709534
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000    -3207.482    -3207.482   -3282.6523   -3282.6523    290.91701    290.91701    47525.084    47525.084   -456.08892   -456.08892 
   23000   -3204.8309   -3204.8309   -3281.4083   -3281.4083    296.36249    296.36249     47543.72     47543.72   -469.04085   -469.04085 
Loop time of 98.5297 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.369 hours/ns, 10.149 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.487     | 97.487     | 97.487     |   0.0 | 98.94
Neigh   | 0.4935     | 0.4935     | 0.4935     |   0.0 |  0.50
Comm    | 0.095568   | 0.095568   | 0.095568   |   0.0 |  0.10
Output  | 0.00026349 | 0.00026349 | 0.00026349 |   0.0 |  0.00
Modify  | 0.3954     | 0.3954     | 0.3954     |   0.0 |  0.40
Other   |            | 0.05771    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3324.00 ave        3324 max        3324 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      118998.0 ave      118998 max      118998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118998
Ave neighs/atom = 59.499000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.362722900278, Press = -0.336946376928201
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -3204.8309   -3204.8309   -3281.4083   -3281.4083    296.36249    296.36249     47543.72     47543.72   -469.04085   -469.04085 
   24000   -3206.6455   -3206.6455   -3282.9659   -3282.9659    295.36798    295.36798    47458.377    47458.377     -273.512     -273.512 
Loop time of 98.0032 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.223 hours/ns, 10.204 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    | 96.961     | 96.961     | 96.961     |   0.0 | 98.94
Neigh   | 0.496      | 0.496      | 0.496      |   0.0 |  0.51
Comm    | 0.096459   | 0.096459   | 0.096459   |   0.0 |  0.10
Output  | 0.00015371 | 0.00015371 | 0.00015371 |   0.0 |  0.00
Modify  | 0.39313    | 0.39313    | 0.39313    |   0.0 |  0.40
Other   |            | 0.05682    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3327.00 ave        3327 max        3327 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      118992.0 ave      118992 max      118992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118992
Ave neighs/atom = 59.496000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.29688841066, Press = -1.14535325261933
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -3206.6455   -3206.6455   -3282.9659   -3282.9659    295.36798    295.36798    47458.377    47458.377     -273.512     -273.512 
   25000   -3207.7094   -3207.7094   -3284.5472   -3284.5472    297.37017    297.37017    47162.476    47162.476    263.80817    263.80817 
Loop time of 96.8897 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.892 ns/day, 26.914 hours/ns, 10.321 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.854     | 95.854     | 95.854     |   0.0 | 98.93
Neigh   | 0.49492    | 0.49492    | 0.49492    |   0.0 |  0.51
Comm    | 0.095004   | 0.095004   | 0.095004   |   0.0 |  0.10
Output  | 0.0001498  | 0.0001498  | 0.0001498  |   0.0 |  0.00
Modify  | 0.3886     | 0.3886     | 0.3886     |   0.0 |  0.40
Other   |            | 0.05733    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3335.00 ave        3335 max        3335 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119640.0 ave      119640 max      119640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119640
Ave neighs/atom = 59.820000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.348670210232, Press = -1.03416419674075
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -3207.7094   -3207.7094   -3284.5472   -3284.5472    297.37017    297.37017    47162.476    47162.476    263.80817    263.80817 
   26000   -3207.6757   -3207.6757   -3283.1791   -3283.1791    292.20622    292.20622    47177.082    47177.082    301.16708    301.16708 
Loop time of 99.5411 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.650 hours/ns, 10.046 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.461     | 98.461     | 98.461     |   0.0 | 98.92
Neigh   | 0.52472    | 0.52472    | 0.52472    |   0.0 |  0.53
Comm    | 0.096574   | 0.096574   | 0.096574   |   0.0 |  0.10
Output  | 0.00015498 | 0.00015498 | 0.00015498 |   0.0 |  0.00
Modify  | 0.39985    | 0.39985    | 0.39985    |   0.0 |  0.40
Other   |            | 0.05831    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3326.00 ave        3326 max        3326 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119764.0 ave      119764 max      119764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119764
Ave neighs/atom = 59.882000
Neighbor list builds = 24
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.385262447392, Press = 1.13878253380399
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -3207.6757   -3207.6757   -3283.1791   -3283.1791    292.20622    292.20622    47177.082    47177.082    301.16708    301.16708 
   27000   -3207.0158   -3207.0158   -3284.2125   -3284.2125     298.7595     298.7595     47588.36     47588.36   -585.26069   -585.26069 
Loop time of 95.1791 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.908 ns/day, 26.439 hours/ns, 10.507 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.181     | 94.181     | 94.181     |   0.0 | 98.95
Neigh   | 0.46868    | 0.46868    | 0.46868    |   0.0 |  0.49
Comm    | 0.09237    | 0.09237    | 0.09237    |   0.0 |  0.10
Output  | 0.0002155  | 0.0002155  | 0.0002155  |   0.0 |  0.00
Modify  | 0.38052    | 0.38052    | 0.38052    |   0.0 |  0.40
Other   |            | 0.05681    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3315.00 ave        3315 max        3315 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119134.0 ave      119134 max      119134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119134
Ave neighs/atom = 59.567000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.492018055378, Press = 0.526394632889313
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -3207.0158   -3207.0158   -3284.2125   -3284.2125     298.7595     298.7595     47588.36     47588.36   -585.26069   -585.26069 
   28000    -3207.818    -3207.818   -3283.7949   -3283.7949    294.03843    294.03843    47406.656    47406.656   -341.81793   -341.81793 
Loop time of 98.6348 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.399 hours/ns, 10.138 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.577     | 97.577     | 97.577     |   0.0 | 98.93
Neigh   | 0.50565    | 0.50565    | 0.50565    |   0.0 |  0.51
Comm    | 0.096277   | 0.096277   | 0.096277   |   0.0 |  0.10
Output  | 0.00018679 | 0.00018679 | 0.00018679 |   0.0 |  0.00
Modify  | 0.39815    | 0.39815    | 0.39815    |   0.0 |  0.40
Other   |            | 0.05806    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3300.00 ave        3300 max        3300 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119164.0 ave      119164 max      119164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119164
Ave neighs/atom = 59.582000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.544762766766, Press = -2.03569717949755
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000    -3207.818    -3207.818   -3283.7949   -3283.7949    294.03843    294.03843    47406.656    47406.656   -341.81793   -341.81793 
   29000    -3205.733    -3205.733   -3280.3848   -3280.3848    288.91026    288.91026    47238.173    47238.173    351.52336    351.52336 
Loop time of 95.6557 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.571 hours/ns, 10.454 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    | 94.637     | 94.637     | 94.637     |   0.0 | 98.93
Neigh   | 0.49008    | 0.49008    | 0.49008    |   0.0 |  0.51
Comm    | 0.093227   | 0.093227   | 0.093227   |   0.0 |  0.10
Output  | 0.00015451 | 0.00015451 | 0.00015451 |   0.0 |  0.00
Modify  | 0.3789     | 0.3789     | 0.3789     |   0.0 |  0.40
Other   |            | 0.05662    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3334.00 ave        3334 max        3334 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119570.0 ave      119570 max      119570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119570
Ave neighs/atom = 59.785000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.612435875502, Press = -1.20021350057879
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000    -3205.733    -3205.733   -3280.3848   -3280.3848    288.91026    288.91026    47238.173    47238.173    351.52336    351.52336 
   30000   -3205.7662   -3205.7662   -3282.5914   -3282.5914    297.32138    297.32138    47233.769    47233.769    275.97776    275.97776 
Loop time of 96.8278 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.892 ns/day, 26.897 hours/ns, 10.328 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.82      | 95.82      | 95.82      |   0.0 | 98.96
Neigh   | 0.47167    | 0.47167    | 0.47167    |   0.0 |  0.49
Comm    | 0.094026   | 0.094026   | 0.094026   |   0.0 |  0.10
Output  | 0.00015381 | 0.00015381 | 0.00015381 |   0.0 |  0.00
Modify  | 0.3857     | 0.3857     | 0.3857     |   0.0 |  0.40
Other   |            | 0.05649    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3319.00 ave        3319 max        3319 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119524.0 ave      119524 max      119524 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119524
Ave neighs/atom = 59.762000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.526479004112, Press = 0.365402891141677
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -3205.7662   -3205.7662   -3282.5914   -3282.5914    297.32138    297.32138    47233.769    47233.769    275.97776    275.97776 
   31000   -3210.0189   -3210.0189   -3284.0851   -3284.0851    286.64379    286.64379    47333.023    47333.023   -58.757184   -58.757184 
Loop time of 95.9046 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.640 hours/ns, 10.427 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.881     | 94.881     | 94.881     |   0.0 | 98.93
Neigh   | 0.48939    | 0.48939    | 0.48939    |   0.0 |  0.51
Comm    | 0.093483   | 0.093483   | 0.093483   |   0.0 |  0.10
Output  | 0.00020871 | 0.00020871 | 0.00020871 |   0.0 |  0.00
Modify  | 0.38396    | 0.38396    | 0.38396    |   0.0 |  0.40
Other   |            | 0.05628    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3330.00 ave        3330 max        3330 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119464.0 ave      119464 max      119464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119464
Ave neighs/atom = 59.732000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.476650702997, Press = 0.663745250123938
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -3210.0189   -3210.0189   -3284.0851   -3284.0851    286.64379    286.64379    47333.023    47333.023   -58.757184   -58.757184 
   32000   -3208.0736   -3208.0736   -3283.4151   -3283.4151    291.57963    291.57963    47408.836    47408.836   -149.21708   -149.21708 
Loop time of 95.4028 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.906 ns/day, 26.501 hours/ns, 10.482 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.412     | 94.412     | 94.412     |   0.0 | 98.96
Neigh   | 0.46335    | 0.46335    | 0.46335    |   0.0 |  0.49
Comm    | 0.092275   | 0.092275   | 0.092275   |   0.0 |  0.10
Output  | 0.00015367 | 0.00015367 | 0.00015367 |   0.0 |  0.00
Modify  | 0.37826    | 0.37826    | 0.37826    |   0.0 |  0.40
Other   |            | 0.05661    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3297.00 ave        3297 max        3297 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119188.0 ave      119188 max      119188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119188
Ave neighs/atom = 59.594000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.502390570184, Press = -0.324744977918588
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -3208.0736   -3208.0736   -3283.4151   -3283.4151    291.57963    291.57963    47408.836    47408.836   -149.21708   -149.21708 
   33000     -3205.03     -3205.03   -3281.5399   -3281.5399    296.10129    296.10129    47401.469    47401.469   -61.235711   -61.235711 
Loop time of 97.4599 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.887 ns/day, 27.072 hours/ns, 10.261 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.444     | 96.444     | 96.444     |   0.0 | 98.96
Neigh   | 0.47113    | 0.47113    | 0.47113    |   0.0 |  0.48
Comm    | 0.094084   | 0.094084   | 0.094084   |   0.0 |  0.10
Output  | 0.00015625 | 0.00015625 | 0.00015625 |   0.0 |  0.00
Modify  | 0.39282    | 0.39282    | 0.39282    |   0.0 |  0.40
Other   |            | 0.05773    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3321.00 ave        3321 max        3321 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119248.0 ave      119248 max      119248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119248
Ave neighs/atom = 59.624000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.548878049936, Press = -0.810209182310362
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000     -3205.03     -3205.03   -3281.5399   -3281.5399    296.10129    296.10129    47401.469    47401.469   -61.235711   -61.235711 
   34000   -3206.0176   -3206.0176   -3282.2005   -3282.2005    294.83575    294.83575    47308.356    47308.356    184.11278    184.11278 
Loop time of 97.1159 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.890 ns/day, 26.977 hours/ns, 10.297 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.079     | 96.079     | 96.079     |   0.0 | 98.93
Neigh   | 0.49455    | 0.49455    | 0.49455    |   0.0 |  0.51
Comm    | 0.094559   | 0.094559   | 0.094559   |   0.0 |  0.10
Output  | 0.00015501 | 0.00015501 | 0.00015501 |   0.0 |  0.00
Modify  | 0.39       | 0.39       | 0.39       |   0.0 |  0.40
Other   |            | 0.05731    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3319.00 ave        3319 max        3319 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119382.0 ave      119382 max      119382 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119382
Ave neighs/atom = 59.691000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.531158875449, Press = 0.215239400593837
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -3206.0176   -3206.0176   -3282.2005   -3282.2005    294.83575    294.83575    47308.356    47308.356    184.11278    184.11278 
   35000   -3208.9911   -3208.9911   -3283.9292   -3283.9292    290.01805    290.01805    47340.805    47340.805    -97.25009    -97.25009 
Loop time of 95.854 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.626 hours/ns, 10.433 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.855     | 94.855     | 94.855     |   0.0 | 98.96
Neigh   | 0.46872    | 0.46872    | 0.46872    |   0.0 |  0.49
Comm    | 0.092882   | 0.092882   | 0.092882   |   0.0 |  0.10
Output  | 0.00015237 | 0.00015237 | 0.00015237 |   0.0 |  0.00
Modify  | 0.37988    | 0.37988    | 0.37988    |   0.0 |  0.40
Other   |            | 0.05719    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3321.00 ave        3321 max        3321 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119256.0 ave      119256 max      119256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119256
Ave neighs/atom = 59.628000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.590775920558, Press = -0.456098028718074
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -3208.9911   -3208.9911   -3283.9292   -3283.9292    290.01805    290.01805    47340.805    47340.805    -97.25009    -97.25009 
   36000   -3202.4885   -3202.4885    -3280.915    -3280.915    303.51871    303.51871    47314.129    47314.129    206.87818    206.87818 
Loop time of 95.5561 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.904 ns/day, 26.543 hours/ns, 10.465 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.562     | 94.562     | 94.562     |   0.0 | 98.96
Neigh   | 0.46932    | 0.46932    | 0.46932    |   0.0 |  0.49
Comm    | 0.092368   | 0.092368   | 0.092368   |   0.0 |  0.10
Output  | 0.00015669 | 0.00015669 | 0.00015669 |   0.0 |  0.00
Modify  | 0.37645    | 0.37645    | 0.37645    |   0.0 |  0.39
Other   |            | 0.05604    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3317.00 ave        3317 max        3317 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119372.0 ave      119372 max      119372 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119372
Ave neighs/atom = 59.686000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.602797131431, Press = -1.27661202391147
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -3202.4885   -3202.4885    -3280.915    -3280.915    303.51871    303.51871    47314.129    47314.129    206.87818    206.87818 
   37000    -3205.342    -3205.342   -3281.2819   -3281.2819    293.89529    293.89529    46847.069    46847.069    1234.0408    1234.0408 
Loop time of 94.7935 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.911 ns/day, 26.332 hours/ns, 10.549 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 93.78      | 93.78      | 93.78      |   0.0 | 98.93
Neigh   | 0.48898    | 0.48898    | 0.48898    |   0.0 |  0.52
Comm    | 0.093245   | 0.093245   | 0.093245   |   0.0 |  0.10
Output  | 0.00015586 | 0.00015586 | 0.00015586 |   0.0 |  0.00
Modify  | 0.37513    | 0.37513    | 0.37513    |   0.0 |  0.40
Other   |            | 0.05608    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3320.00 ave        3320 max        3320 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120200.0 ave      120200 max      120200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120200
Ave neighs/atom = 60.100000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.628351361851, Press = 0.0835271718990657
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000    -3205.342    -3205.342   -3281.2819   -3281.2819    293.89529    293.89529    46847.069    46847.069    1234.0408    1234.0408 
   38000   -3208.8039   -3208.8039   -3283.1324   -3283.1324    287.65887    287.65887    47357.636    47357.636   -120.40362   -120.40362 
Loop time of 96.2215 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.728 hours/ns, 10.393 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    | 95.199     | 95.199     | 95.199     |   0.0 | 98.94
Neigh   | 0.49198    | 0.49198    | 0.49198    |   0.0 |  0.51
Comm    | 0.093803   | 0.093803   | 0.093803   |   0.0 |  0.10
Output  | 0.00015791 | 0.00015791 | 0.00015791 |   0.0 |  0.00
Modify  | 0.37983    | 0.37983    | 0.37983    |   0.0 |  0.39
Other   |            | 0.05718    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3353.00 ave        3353 max        3353 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119594.0 ave      119594 max      119594 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119594
Ave neighs/atom = 59.797000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.619571810115, Press = 1.00535785180301
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -3208.8039   -3208.8039   -3283.1324   -3283.1324    287.65887    287.65887    47357.636    47357.636   -120.40362   -120.40362 
   39000   -3206.6398   -3206.6398   -3283.6668   -3283.6668    298.10247    298.10247    47418.638    47418.638   -142.39161   -142.39161 
Loop time of 95.9153 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.643 hours/ns, 10.426 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.897     | 94.897     | 94.897     |   0.0 | 98.94
Neigh   | 0.48563    | 0.48563    | 0.48563    |   0.0 |  0.51
Comm    | 0.093064   | 0.093064   | 0.093064   |   0.0 |  0.10
Output  | 0.00021797 | 0.00021797 | 0.00021797 |   0.0 |  0.00
Modify  | 0.38222    | 0.38222    | 0.38222    |   0.0 |  0.40
Other   |            | 0.0572     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3349.00 ave        3349 max        3349 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119018.0 ave      119018 max      119018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119018
Ave neighs/atom = 59.509000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.608953846932, Press = -0.13284212019635
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -3206.6398   -3206.6398   -3283.6668   -3283.6668    298.10247    298.10247    47418.638    47418.638   -142.39161   -142.39161 
   40000   -3205.1315   -3205.1315   -3281.0788   -3281.0788    293.92367    293.92367    47385.276    47385.276   -54.099667   -54.099667 
Loop time of 95.4661 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.905 ns/day, 26.518 hours/ns, 10.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    | 94.467     | 94.467     | 94.467     |   0.0 | 98.95
Neigh   | 0.47118    | 0.47118    | 0.47118    |   0.0 |  0.49
Comm    | 0.092836   | 0.092836   | 0.092836   |   0.0 |  0.10
Output  | 0.00015389 | 0.00015389 | 0.00015389 |   0.0 |  0.00
Modify  | 0.37788    | 0.37788    | 0.37788    |   0.0 |  0.40
Other   |            | 0.05679    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3368.00 ave        3368 max        3368 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119264.0 ave      119264 max      119264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119264
Ave neighs/atom = 59.632000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.5987848536, Press = -0.165522245375786
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -3205.1315   -3205.1315   -3281.0788   -3281.0788    293.92367    293.92367    47385.276    47385.276   -54.099667   -54.099667 
   41000   -3206.1295   -3206.1295    -3283.322    -3283.322    298.74316    298.74316    47248.413    47248.413    167.12953    167.12953 
Loop time of 94.8416 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.911 ns/day, 26.345 hours/ns, 10.544 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    | 93.856     | 93.856     | 93.856     |   0.0 | 98.96
Neigh   | 0.46066    | 0.46066    | 0.46066    |   0.0 |  0.49
Comm    | 0.092286   | 0.092286   | 0.092286   |   0.0 |  0.10
Output  | 0.00015527 | 0.00015527 | 0.00015527 |   0.0 |  0.00
Modify  | 0.37629    | 0.37629    | 0.37629    |   0.0 |  0.40
Other   |            | 0.05647    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3335.00 ave        3335 max        3335 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119674.0 ave      119674 max      119674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119674
Ave neighs/atom = 59.837000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.59677326393, Press = 0.348198694599278
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -3206.1295   -3206.1295    -3283.322    -3283.322    298.74316    298.74316    47248.413    47248.413    167.12953    167.12953 
   42000   -3210.6384   -3210.6384   -3284.6117   -3284.6117    286.28435    286.28435    47389.637    47389.637   -312.59926   -312.59926 
Loop time of 95.6718 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.903 ns/day, 26.575 hours/ns, 10.452 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.648     | 94.648     | 94.648     |   0.0 | 98.93
Neigh   | 0.49267    | 0.49267    | 0.49267    |   0.0 |  0.51
Comm    | 0.094078   | 0.094078   | 0.094078   |   0.0 |  0.10
Output  | 0.0002033  | 0.0002033  | 0.0002033  |   0.0 |  0.00
Modify  | 0.38005    | 0.38005    | 0.38005    |   0.0 |  0.40
Other   |            | 0.05707    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3364.00 ave        3364 max        3364 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119342.0 ave      119342 max      119342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119342
Ave neighs/atom = 59.671000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.584609775318, Press = 1.2151752635509
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -3210.6384   -3210.6384   -3284.6117   -3284.6117    286.28435    286.28435    47389.637    47389.637   -312.59926   -312.59926 
   43000   -3208.0128   -3208.0128   -3280.9724   -3280.9724     282.3611     282.3611    47561.833    47561.833   -634.50905   -634.50905 
Loop time of 97.0911 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.890 ns/day, 26.970 hours/ns, 10.300 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.06      | 96.06      | 96.06      |   0.0 | 98.94
Neigh   | 0.4897     | 0.4897     | 0.4897     |   0.0 |  0.50
Comm    | 0.094617   | 0.094617   | 0.094617   |   0.0 |  0.10
Output  | 0.00019509 | 0.00019509 | 0.00019509 |   0.0 |  0.00
Modify  | 0.38931    | 0.38931    | 0.38931    |   0.0 |  0.40
Other   |            | 0.05736    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3342.00 ave        3342 max        3342 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      118834.0 ave      118834 max      118834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118834
Ave neighs/atom = 59.417000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.535475617296, Press = -0.0898952531843685
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -3208.0128   -3208.0128   -3280.9724   -3280.9724     282.3611     282.3611    47561.833    47561.833   -634.50905   -634.50905 
   44000   -3204.5863   -3204.5863   -3280.2579   -3280.2579    292.85705    292.85705    47355.693    47355.693   -110.11247   -110.11247 
Loop time of 96.9134 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.892 ns/day, 26.920 hours/ns, 10.318 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    | 95.877     | 95.877     | 95.877     |   0.0 | 98.93
Neigh   | 0.49739    | 0.49739    | 0.49739    |   0.0 |  0.51
Comm    | 0.093844   | 0.093844   | 0.093844   |   0.0 |  0.10
Output  | 0.00018929 | 0.00018929 | 0.00018929 |   0.0 |  0.00
Modify  | 0.38848    | 0.38848    | 0.38848    |   0.0 |  0.40
Other   |            | 0.05673    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3324.00 ave        3324 max        3324 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119074.0 ave      119074 max      119074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119074
Ave neighs/atom = 59.537000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.563263494939, Press = -0.875654103276463
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -3204.5863   -3204.5863   -3280.2579   -3280.2579    292.85705    292.85705    47355.693    47355.693   -110.11247   -110.11247 
   45000    -3205.156    -3205.156   -3282.2336   -3282.2336    298.29835    298.29835    47217.438    47217.438    207.68407    207.68407 
Loop time of 97.8525 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.181 hours/ns, 10.219 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.827     | 96.827     | 96.827     |   0.0 | 98.95
Neigh   | 0.47812    | 0.47812    | 0.47812    |   0.0 |  0.49
Comm    | 0.095624   | 0.095624   | 0.095624   |   0.0 |  0.10
Output  | 0.00019497 | 0.00019497 | 0.00019497 |   0.0 |  0.00
Modify  | 0.39339    | 0.39339    | 0.39339    |   0.0 |  0.40
Other   |            | 0.05792    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3351.00 ave        3351 max        3351 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119608.0 ave      119608 max      119608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119608
Ave neighs/atom = 59.804000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.531337756838, Press = 0.0912055858109599
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000    -3205.156    -3205.156   -3282.2336   -3282.2336    298.29835    298.29835    47217.438    47217.438    207.68407    207.68407 
   46000   -3205.9838   -3205.9838   -3282.6679   -3282.6679    296.77538    296.77538    47351.801    47351.801   -117.96294   -117.96294 
Loop time of 96.1777 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.716 hours/ns, 10.397 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.157     | 95.157     | 95.157     |   0.0 | 98.94
Neigh   | 0.48682    | 0.48682    | 0.48682    |   0.0 |  0.51
Comm    | 0.094734   | 0.094734   | 0.094734   |   0.0 |  0.10
Output  | 0.00015671 | 0.00015671 | 0.00015671 |   0.0 |  0.00
Modify  | 0.3823     | 0.3823     | 0.3823     |   0.0 |  0.40
Other   |            | 0.05668    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3351.00 ave        3351 max        3351 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119474.0 ave      119474 max      119474 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119474
Ave neighs/atom = 59.737000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.497039562981, Press = 0.134644622043245
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -3205.9838   -3205.9838   -3282.6679   -3282.6679    296.77538    296.77538    47351.801    47351.801   -117.96294   -117.96294 
   47000   -3210.3012   -3210.3012   -3285.1061   -3285.1061     289.5026     289.5026    47276.009    47276.009    88.441055    88.441055 
Loop time of 95.7718 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.603 hours/ns, 10.441 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.736     | 94.736     | 94.736     |   0.0 | 98.92
Neigh   | 0.49636    | 0.49636    | 0.49636    |   0.0 |  0.52
Comm    | 0.094902   | 0.094902   | 0.094902   |   0.0 |  0.10
Output  | 0.00020313 | 0.00020313 | 0.00020313 |   0.0 |  0.00
Modify  | 0.38675    | 0.38675    | 0.38675    |   0.0 |  0.40
Other   |            | 0.0572     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3355.00 ave        3355 max        3355 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119398.0 ave      119398 max      119398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119398
Ave neighs/atom = 59.699000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.478709344583, Press = -0.0681760826848965
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -3210.3012   -3210.3012   -3285.1061   -3285.1061     289.5026     289.5026    47276.009    47276.009    88.441055    88.441055 
   48000   -3206.5881   -3206.5881   -3282.7291   -3282.7291    294.67383    294.67383     47499.43     47499.43   -326.52545   -326.52545 
Loop time of 94.3472 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.916 ns/day, 26.208 hours/ns, 10.599 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 93.355     | 93.355     | 93.355     |   0.0 | 98.95
Neigh   | 0.4661     | 0.4661     | 0.4661     |   0.0 |  0.49
Comm    | 0.092642   | 0.092642   | 0.092642   |   0.0 |  0.10
Output  | 0.0002534  | 0.0002534  | 0.0002534  |   0.0 |  0.00
Modify  | 0.37596    | 0.37596    | 0.37596    |   0.0 |  0.40
Other   |            | 0.05705    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3295.00 ave        3295 max        3295 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119144.0 ave      119144 max      119144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119144
Ave neighs/atom = 59.572000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.462346479894, Press = -0.243258292398443
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -3206.5881   -3206.5881   -3282.7291   -3282.7291    294.67383    294.67383     47499.43     47499.43   -326.52545   -326.52545 
   49000   -3206.3032   -3206.3032   -3281.3043   -3281.3043    290.26203    290.26203     47224.57     47224.57    123.13015    123.13015 
Loop time of 97.3158 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.888 ns/day, 27.032 hours/ns, 10.276 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.271     | 96.271     | 96.271     |   0.0 | 98.93
Neigh   | 0.50442    | 0.50442    | 0.50442    |   0.0 |  0.52
Comm    | 0.094781   | 0.094781   | 0.094781   |   0.0 |  0.10
Output  | 0.0001578  | 0.0001578  | 0.0001578  |   0.0 |  0.00
Modify  | 0.38858    | 0.38858    | 0.38858    |   0.0 |  0.40
Other   |            | 0.05717    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3331.00 ave        3331 max        3331 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119648.0 ave      119648 max      119648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119648
Ave neighs/atom = 59.824000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.472229637915, Press = -0.903792256136881
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -3206.3032   -3206.3032   -3281.3043   -3281.3043    290.26203    290.26203     47224.57     47224.57    123.13015    123.13015 
   50000   -3202.7832   -3202.7832   -3280.1708   -3280.1708    299.49798    299.49798    47191.788    47191.788    411.43725    411.43725 
Loop time of 96.2034 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.723 hours/ns, 10.395 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.181     | 95.181     | 95.181     |   0.0 | 98.94
Neigh   | 0.48952    | 0.48952    | 0.48952    |   0.0 |  0.51
Comm    | 0.094236   | 0.094236   | 0.094236   |   0.0 |  0.10
Output  | 0.00015631 | 0.00015631 | 0.00015631 |   0.0 |  0.00
Modify  | 0.38211    | 0.38211    | 0.38211    |   0.0 |  0.40
Other   |            | 0.05675    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3349.00 ave        3349 max        3349 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119602.0 ave      119602 max      119602 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119602
Ave neighs/atom = 59.801000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.512235197673, Press = 0.32674183571324
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -3202.7832   -3202.7832   -3280.1708   -3280.1708    299.49798    299.49798    47191.788    47191.788    411.43725    411.43725 
   51000   -3208.5553   -3208.5553   -3282.9765   -3282.9765    288.01755    288.01755    47548.899    47548.899   -522.93877   -522.93877 
Loop time of 95.7991 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.611 hours/ns, 10.439 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.803     | 94.803     | 94.803     |   0.0 | 98.96
Neigh   | 0.4657     | 0.4657     | 0.4657     |   0.0 |  0.49
Comm    | 0.093283   | 0.093283   | 0.093283   |   0.0 |  0.10
Output  | 0.00015417 | 0.00015417 | 0.00015417 |   0.0 |  0.00
Modify  | 0.3803     | 0.3803     | 0.3803     |   0.0 |  0.40
Other   |            | 0.05684    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3296.00 ave        3296 max        3296 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119188.0 ave      119188 max      119188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119188
Ave neighs/atom = 59.594000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.497843383785, Press = -0.0245805664139467
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -3208.5553   -3208.5553   -3282.9765   -3282.9765    288.01755    288.01755    47548.899    47548.899   -522.93877   -522.93877 
   52000   -3206.2795   -3206.2795   -3281.7713   -3281.7713    292.16109    292.16109    47419.357    47419.357    -253.3142    -253.3142 
Loop time of 96.4506 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.792 hours/ns, 10.368 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.424     | 95.424     | 95.424     |   0.0 | 98.94
Neigh   | 0.4905     | 0.4905     | 0.4905     |   0.0 |  0.51
Comm    | 0.094468   | 0.094468   | 0.094468   |   0.0 |  0.10
Output  | 0.00015621 | 0.00015621 | 0.00015621 |   0.0 |  0.00
Modify  | 0.38484    | 0.38484    | 0.38484    |   0.0 |  0.40
Other   |            | 0.05681    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3314.00 ave        3314 max        3314 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119036.0 ave      119036 max      119036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119036
Ave neighs/atom = 59.518000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.461187942494, Press = -1.3459827518891
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -3206.2795   -3206.2795   -3281.7713   -3281.7713    292.16109    292.16109    47419.357    47419.357    -253.3142    -253.3142 
   53000   -3207.2373   -3207.2373   -3283.1482   -3283.1482      293.783      293.783    47147.588    47147.588    332.28496    332.28496 
Loop time of 95.5903 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.904 ns/day, 26.553 hours/ns, 10.461 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.567     | 94.567     | 94.567     |   0.0 | 98.93
Neigh   | 0.49189    | 0.49189    | 0.49189    |   0.0 |  0.51
Comm    | 0.093343   | 0.093343   | 0.093343   |   0.0 |  0.10
Output  | 0.00015299 | 0.00015299 | 0.00015299 |   0.0 |  0.00
Modify  | 0.38118    | 0.38118    | 0.38118    |   0.0 |  0.40
Other   |            | 0.05711    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3355.00 ave        3355 max        3355 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119588.0 ave      119588 max      119588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119588
Ave neighs/atom = 59.794000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.452266211052, Press = -0.478260745128878
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -3207.2373   -3207.2373   -3283.1482   -3283.1482      293.783      293.783    47147.588    47147.588    332.28496    332.28496 
   54000   -3203.6014   -3203.6014   -3283.7732   -3283.7732    310.27339    310.27339    47239.512    47239.512    268.33473    268.33473 
Loop time of 93.1645 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.927 ns/day, 25.879 hours/ns, 10.734 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    | 92.169     | 92.169     | 92.169     |   0.0 | 98.93
Neigh   | 0.47917    | 0.47917    | 0.47917    |   0.0 |  0.51
Comm    | 0.091087   | 0.091087   | 0.091087   |   0.0 |  0.10
Output  | 0.00015358 | 0.00015358 | 0.00015358 |   0.0 |  0.00
Modify  | 0.36899    | 0.36899    | 0.36899    |   0.0 |  0.40
Other   |            | 0.05592    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3334.00 ave        3334 max        3334 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119684.0 ave      119684 max      119684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119684
Ave neighs/atom = 59.842000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.446590177061, Press = 0.348778878131722
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -3203.6014   -3203.6014   -3283.7732   -3283.7732    310.27339    310.27339    47239.512    47239.512    268.33473    268.33473 
   55000   -3206.9138   -3206.9138   -3282.0865   -3282.0865    290.92618    290.92618    47397.848    47397.848   -95.376935   -95.376935 
Loop time of 93.73 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.922 ns/day, 26.036 hours/ns, 10.669 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 92.72      | 92.72      | 92.72      |   0.0 | 98.92
Neigh   | 0.4889     | 0.4889     | 0.4889     |   0.0 |  0.52
Comm    | 0.09253    | 0.09253    | 0.09253    |   0.0 |  0.10
Output  | 0.00015356 | 0.00015356 | 0.00015356 |   0.0 |  0.00
Modify  | 0.37245    | 0.37245    | 0.37245    |   0.0 |  0.40
Other   |            | 0.05582    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3310.00 ave        3310 max        3310 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119148.0 ave      119148 max      119148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119148
Ave neighs/atom = 59.574000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.437852043784, Press = 0.156237791456551
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -3206.9138   -3206.9138   -3282.0865   -3282.0865    290.92618    290.92618    47397.848    47397.848   -95.376935   -95.376935 
   56000   -3205.4581   -3205.4581   -3281.9137   -3281.9137    295.89113    295.89113    47377.025    47377.025    -135.3264    -135.3264 
Loop time of 93.5014 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.924 ns/day, 25.973 hours/ns, 10.695 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 92.488     | 92.488     | 92.488     |   0.0 | 98.92
Neigh   | 0.49122    | 0.49122    | 0.49122    |   0.0 |  0.53
Comm    | 0.092542   | 0.092542   | 0.092542   |   0.0 |  0.10
Output  | 0.00046004 | 0.00046004 | 0.00046004 |   0.0 |  0.00
Modify  | 0.37266    | 0.37266    | 0.37266    |   0.0 |  0.40
Other   |            | 0.05631    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3324.00 ave        3324 max        3324 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119232.0 ave      119232 max      119232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119232
Ave neighs/atom = 59.616000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.410346151204, Press = -0.389497831120276
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -3205.4581   -3205.4581   -3281.9137   -3281.9137    295.89113    295.89113    47377.025    47377.025    -135.3264    -135.3264 
   57000   -3205.6553   -3205.6553   -3282.1726   -3282.1726    296.12991    296.12991    47074.947    47074.947    618.45123    618.45123 
Loop time of 94.9841 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.910 ns/day, 26.384 hours/ns, 10.528 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 93.968     | 93.968     | 93.968     |   0.0 | 98.93
Neigh   | 0.48856    | 0.48856    | 0.48856    |   0.0 |  0.51
Comm    | 0.092862   | 0.092862   | 0.092862   |   0.0 |  0.10
Output  | 0.00015594 | 0.00015594 | 0.00015594 |   0.0 |  0.00
Modify  | 0.37844    | 0.37844    | 0.37844    |   0.0 |  0.40
Other   |            | 0.05623    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3358.00 ave        3358 max        3358 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120076.0 ave      120076 max      120076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120076
Ave neighs/atom = 60.038000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.399733052289, Press = -0.423969081455407
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -3205.6553   -3205.6553   -3282.1726   -3282.1726    296.12991    296.12991    47074.947    47074.947    618.45123    618.45123 
   58000   -3203.7936   -3203.7936   -3281.9768   -3281.9768    302.57709    302.57709    47196.776    47196.776    310.89741    310.89741 
Loop time of 95.7869 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.902 ns/day, 26.607 hours/ns, 10.440 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.787     | 94.787     | 94.787     |   0.0 | 98.96
Neigh   | 0.46751    | 0.46751    | 0.46751    |   0.0 |  0.49
Comm    | 0.093747   | 0.093747   | 0.093747   |   0.0 |  0.10
Output  | 0.00015515 | 0.00015515 | 0.00015515 |   0.0 |  0.00
Modify  | 0.38173    | 0.38173    | 0.38173    |   0.0 |  0.40
Other   |            | 0.05651    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3308.00 ave        3308 max        3308 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119794.0 ave      119794 max      119794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119794
Ave neighs/atom = 59.897000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.383723000971, Press = 0.579500078735017
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -3203.7936   -3203.7936   -3281.9768   -3281.9768    302.57709    302.57709    47196.776    47196.776    310.89741    310.89741 
   59000   -3204.7395   -3204.7395   -3281.7485   -3281.7485     298.0329     298.0329    47437.911    47437.911    -252.7653    -252.7653 
Loop time of 92.9861 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.929 ns/day, 25.829 hours/ns, 10.754 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    | 91.987     | 91.987     | 91.987     |   0.0 | 98.93
Neigh   | 0.48332    | 0.48332    | 0.48332    |   0.0 |  0.52
Comm    | 0.091263   | 0.091263   | 0.091263   |   0.0 |  0.10
Output  | 0.00015286 | 0.00015286 | 0.00015286 |   0.0 |  0.00
Modify  | 0.36872    | 0.36872    | 0.36872    |   0.0 |  0.40
Other   |            | 0.05562    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3361.00 ave        3361 max        3361 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119330.0 ave      119330 max      119330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119330
Ave neighs/atom = 59.665000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.390598998213, Press = 0.489247664288341
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -3204.7395   -3204.7395   -3281.7485   -3281.7485     298.0329     298.0329    47437.911    47437.911    -252.7653    -252.7653 
   60000   -3210.7677   -3210.7677   -3284.6757   -3284.6757    286.03169    286.03169    47325.006    47325.006   -106.45202   -106.45202 
Loop time of 94.9627 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.910 ns/day, 26.379 hours/ns, 10.530 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 93.969     | 93.969     | 93.969     |   0.0 | 98.95
Neigh   | 0.46541    | 0.46541    | 0.46541    |   0.0 |  0.49
Comm    | 0.092298   | 0.092298   | 0.092298   |   0.0 |  0.10
Output  | 0.00015648 | 0.00015648 | 0.00015648 |   0.0 |  0.00
Modify  | 0.37942    | 0.37942    | 0.37942    |   0.0 |  0.40
Other   |            | 0.05671    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3301.00 ave        3301 max        3301 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119224.0 ave      119224 max      119224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119224
Ave neighs/atom = 59.612000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.424805819463, Press = -0.336182786334642
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -3210.7677   -3210.7677   -3284.6757   -3284.6757    286.03169    286.03169    47325.006    47325.006   -106.45202   -106.45202 
   61000   -3204.1109   -3204.1109   -3281.7318   -3281.7318      300.401      300.401    47227.844    47227.844    319.72626    319.72626 
Loop time of 93.255 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.926 ns/day, 25.904 hours/ns, 10.723 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 92.279     | 92.279     | 92.279     |   0.0 | 98.95
Neigh   | 0.45998    | 0.45998    | 0.45998    |   0.0 |  0.49
Comm    | 0.090833   | 0.090833   | 0.090833   |   0.0 |  0.10
Output  | 0.00015442 | 0.00015442 | 0.00015442 |   0.0 |  0.00
Modify  | 0.36943    | 0.36943    | 0.36943    |   0.0 |  0.40
Other   |            | 0.05596    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3340.00 ave        3340 max        3340 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119334.0 ave      119334 max      119334 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119334
Ave neighs/atom = 59.667000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.412430827875, Press = -0.330275045781299
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -3204.1109   -3204.1109   -3281.7318   -3281.7318      300.401      300.401    47227.844    47227.844    319.72626    319.72626 
   62000   -3207.1286   -3207.1286   -3282.5653   -3282.5653    291.94771    291.94771     47178.11     47178.11    290.14152    290.14152 
Loop time of 94.9449 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.910 ns/day, 26.374 hours/ns, 10.532 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 93.947     | 93.947     | 93.947     |   0.0 | 98.95
Neigh   | 0.46843    | 0.46843    | 0.46843    |   0.0 |  0.49
Comm    | 0.093021   | 0.093021   | 0.093021   |   0.0 |  0.10
Output  | 0.00019097 | 0.00019097 | 0.00019097 |   0.0 |  0.00
Modify  | 0.37967    | 0.37967    | 0.37967    |   0.0 |  0.40
Other   |            | 0.05673    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3333.00 ave        3333 max        3333 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119918.0 ave      119918 max      119918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119918
Ave neighs/atom = 59.959000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.409556459023, Press = 0.0362781508488056
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -3207.1286   -3207.1286   -3282.5653   -3282.5653    291.94771    291.94771     47178.11     47178.11    290.14152    290.14152 
   63000   -3205.5187   -3205.5187   -3282.3828   -3282.3828    297.47206    297.47206     47461.39     47461.39   -151.40446   -151.40446 
Loop time of 94.7921 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.911 ns/day, 26.331 hours/ns, 10.549 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 93.776     | 93.776     | 93.776     |   0.0 | 98.93
Neigh   | 0.4876     | 0.4876     | 0.4876     |   0.0 |  0.51
Comm    | 0.09309    | 0.09309    | 0.09309    |   0.0 |  0.10
Output  | 0.00015524 | 0.00015524 | 0.00015524 |   0.0 |  0.00
Modify  | 0.37822    | 0.37822    | 0.37822    |   0.0 |  0.40
Other   |            | 0.05655    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3348.00 ave        3348 max        3348 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119276.0 ave      119276 max      119276 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119276
Ave neighs/atom = 59.638000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.381714932896, Press = 0.77721577596726
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -3205.5187   -3205.5187   -3282.3828   -3282.3828    297.47206    297.47206     47461.39     47461.39   -151.40446   -151.40446 
   64000   -3209.5385   -3209.5385   -3285.0531   -3285.0531    292.24949    292.24949    47627.244    47627.244   -794.39932   -794.39932 
Loop time of 95.2488 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.907 ns/day, 26.458 hours/ns, 10.499 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    | 94.234     | 94.234     | 94.234     |   0.0 | 98.93
Neigh   | 0.48635    | 0.48635    | 0.48635    |   0.0 |  0.51
Comm    | 0.094102   | 0.094102   | 0.094102   |   0.0 |  0.10
Output  | 0.00019275 | 0.00019275 | 0.00019275 |   0.0 |  0.00
Modify  | 0.37803    | 0.37803    | 0.37803    |   0.0 |  0.40
Other   |            | 0.05655    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3320.00 ave        3320 max        3320 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119038.0 ave      119038 max      119038 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119038
Ave neighs/atom = 59.519000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.355631430899, Press = 0.0348730465881587
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -3209.5385   -3209.5385   -3285.0531   -3285.0531    292.24949    292.24949    47627.244    47627.244   -794.39932   -794.39932 
   65000   -3206.6843   -3206.6843   -3283.8063   -3283.8063    298.46999    298.46999    47219.739    47219.739    346.75065    346.75065 
Loop time of 97.0925 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.890 ns/day, 26.970 hours/ns, 10.299 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.079     | 96.079     | 96.079     |   0.0 | 98.96
Neigh   | 0.46834    | 0.46834    | 0.46834    |   0.0 |  0.48
Comm    | 0.094735   | 0.094735   | 0.094735   |   0.0 |  0.10
Output  | 0.00015493 | 0.00015493 | 0.00015493 |   0.0 |  0.00
Modify  | 0.39257    | 0.39257    | 0.39257    |   0.0 |  0.40
Other   |            | 0.05742    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3365.00 ave        3365 max        3365 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119588.0 ave      119588 max      119588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119588
Ave neighs/atom = 59.794000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.362211387111, Press = -0.280518953176061
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -3206.6843   -3206.6843   -3283.8063   -3283.8063    298.46999    298.46999    47219.739    47219.739    346.75065    346.75065 
   66000   -3207.7358   -3207.7358   -3282.1805   -3282.1805    288.10848    288.10848    47227.985    47227.985    203.01393    203.01393 
Loop time of 95.1878 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.908 ns/day, 26.441 hours/ns, 10.506 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.167     | 94.167     | 94.167     |   0.0 | 98.93
Neigh   | 0.48923    | 0.48923    | 0.48923    |   0.0 |  0.51
Comm    | 0.093583   | 0.093583   | 0.093583   |   0.0 |  0.10
Output  | 0.00015711 | 0.00015711 | 0.00015711 |   0.0 |  0.00
Modify  | 0.38156    | 0.38156    | 0.38156    |   0.0 |  0.40
Other   |            | 0.05654    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3377.00 ave        3377 max        3377 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119442.0 ave      119442 max      119442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119442
Ave neighs/atom = 59.721000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.395288113434, Press = 0.284557554840347
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -3207.7358   -3207.7358   -3282.1805   -3282.1805    288.10848    288.10848    47227.985    47227.985    203.01393    203.01393 
   67000   -3204.4407   -3204.4407   -3281.2078   -3281.2078    297.09675    297.09675    47309.489    47309.489    185.93732    185.93732 
Loop time of 95.8784 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.901 ns/day, 26.633 hours/ns, 10.430 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.868     | 94.868     | 94.868     |   0.0 | 98.95
Neigh   | 0.47977    | 0.47977    | 0.47977    |   0.0 |  0.50
Comm    | 0.093358   | 0.093358   | 0.093358   |   0.0 |  0.10
Output  | 0.00015409 | 0.00015409 | 0.00015409 |   0.0 |  0.00
Modify  | 0.38057    | 0.38057    | 0.38057    |   0.0 |  0.40
Other   |            | 0.05677    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3326.00 ave        3326 max        3326 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119344.0 ave      119344 max      119344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119344
Ave neighs/atom = 59.672000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.410639185728, Press = 0.522906727408532
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -3204.4407   -3204.4407   -3281.2078   -3281.2078    297.09675    297.09675    47309.489    47309.489    185.93732    185.93732 
   68000   -3208.7812   -3208.7812   -3282.9697   -3282.9697    287.11734    287.11734     47476.86     47476.86   -366.68944   -366.68944 
Loop time of 95.2405 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.907 ns/day, 26.456 hours/ns, 10.500 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 94.239     | 94.239     | 94.239     |   0.0 | 98.95
Neigh   | 0.4732     | 0.4732     | 0.4732     |   0.0 |  0.50
Comm    | 0.092839   | 0.092839   | 0.092839   |   0.0 |  0.10
Output  | 0.00015345 | 0.00015345 | 0.00015345 |   0.0 |  0.00
Modify  | 0.37853    | 0.37853    | 0.37853    |   0.0 |  0.40
Other   |            | 0.05666    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3329.00 ave        3329 max        3329 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119154.0 ave      119154 max      119154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119154
Ave neighs/atom = 59.577000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.42222773658, Press = 0.581670146677829
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000   -3208.7812   -3208.7812   -3282.9697   -3282.9697    287.11734    287.11734     47476.86     47476.86   -366.68944   -366.68944 
   69000   -3207.1942   -3207.1942   -3281.9006   -3281.9006    289.12141    289.12141    47410.633    47410.633   -350.92847   -350.92847 
Loop time of 93.8488 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.921 ns/day, 26.069 hours/ns, 10.655 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 92.868     | 92.868     | 92.868     |   0.0 | 98.95
Neigh   | 0.45965    | 0.45965    | 0.45965    |   0.0 |  0.49
Comm    | 0.091787   | 0.091787   | 0.091787   |   0.0 |  0.10
Output  | 0.00015469 | 0.00015469 | 0.00015469 |   0.0 |  0.00
Modify  | 0.37287    | 0.37287    | 0.37287    |   0.0 |  0.40
Other   |            | 0.05666    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3344.00 ave        3344 max        3344 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119134.0 ave      119134 max      119134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119134
Ave neighs/atom = 59.567000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.437821756003, Press = -0.209762795772129
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -3207.1942   -3207.1942   -3281.9006   -3281.9006    289.12141    289.12141    47410.633    47410.633   -350.92847   -350.92847 
   70000   -3206.9108   -3206.9108   -3285.4056   -3285.4056    303.78331    303.78331     47227.87     47227.87    235.84703    235.84703 
Loop time of 94.351 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.916 ns/day, 26.209 hours/ns, 10.599 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 93.33      | 93.33      | 93.33      |   0.0 | 98.92
Neigh   | 0.49511    | 0.49511    | 0.49511    |   0.0 |  0.52
Comm    | 0.093392   | 0.093392   | 0.093392   |   0.0 |  0.10
Output  | 0.00015535 | 0.00015535 | 0.00015535 |   0.0 |  0.00
Modify  | 0.37601    | 0.37601    | 0.37601    |   0.0 |  0.40
Other   |            | 0.05665    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3372.00 ave        3372 max        3372 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119176.0 ave      119176 max      119176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119176
Ave neighs/atom = 59.588000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.441882214329, Press = -0.582373836482189
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -3206.9108   -3206.9108   -3285.4056   -3285.4056    303.78331    303.78331     47227.87     47227.87    235.84703    235.84703 
   71000   -3203.8143   -3203.8143    -3281.051    -3281.051    298.91389    298.91389    47224.643    47224.643    322.70698    322.70698 
Loop time of 97.8289 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.175 hours/ns, 10.222 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.81      | 96.81      | 96.81      |   0.0 | 98.96
Neigh   | 0.47258    | 0.47258    | 0.47258    |   0.0 |  0.48
Comm    | 0.095451   | 0.095451   | 0.095451   |   0.0 |  0.10
Output  | 0.00015572 | 0.00015572 | 0.00015572 |   0.0 |  0.00
Modify  | 0.39331    | 0.39331    | 0.39331    |   0.0 |  0.40
Other   |            | 0.05763    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3314.00 ave        3314 max        3314 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119588.0 ave      119588 max      119588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119588
Ave neighs/atom = 59.794000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.4164298687, Press = 0.182125291544554
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -3203.8143   -3203.8143    -3281.051    -3281.051    298.91389    298.91389    47224.643    47224.643    322.70698    322.70698 
   72000   -3206.4154   -3206.4154   -3282.8188   -3282.8188    295.68897    295.68897     47342.62     47342.62   -117.16775   -117.16775 
Loop time of 95.0071 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.909 ns/day, 26.391 hours/ns, 10.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    | 93.978     | 93.978     | 93.978     |   0.0 | 98.92
Neigh   | 0.49674    | 0.49674    | 0.49674    |   0.0 |  0.52
Comm    | 0.094493   | 0.094493   | 0.094493   |   0.0 |  0.10
Output  | 0.00018699 | 0.00018699 | 0.00018699 |   0.0 |  0.00
Modify  | 0.38095    | 0.38095    | 0.38095    |   0.0 |  0.40
Other   |            | 0.05699    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3349.00 ave        3349 max        3349 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119268.0 ave      119268 max      119268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119268
Ave neighs/atom = 59.634000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.416662431011, Press = 0.133951478756466
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -3206.4154   -3206.4154   -3282.8188   -3282.8188    295.68897    295.68897     47342.62     47342.62   -117.16775   -117.16775 
   73000   -3207.0277   -3207.0277   -3282.1058   -3282.1058    290.56016    290.56016     47268.81     47268.81    230.97436    230.97436 
Loop time of 93.108 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.928 ns/day, 25.863 hours/ns, 10.740 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 92.104     | 92.104     | 92.104     |   0.0 | 98.92
Neigh   | 0.48892    | 0.48892    | 0.48892    |   0.0 |  0.53
Comm    | 0.091894   | 0.091894   | 0.091894   |   0.0 |  0.10
Output  | 0.0001538  | 0.0001538  | 0.0001538  |   0.0 |  0.00
Modify  | 0.36781    | 0.36781    | 0.36781    |   0.0 |  0.40
Other   |            | 0.0556     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3345.00 ave        3345 max        3345 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119464.0 ave      119464 max      119464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119464
Ave neighs/atom = 59.732000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.380647477996, Press = 0.00626109641096869
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -3207.0277   -3207.0277   -3282.1058   -3282.1058    290.56016    290.56016     47268.81     47268.81    230.97436    230.97436 
   74000    -3210.224    -3210.224   -3284.8517   -3284.8517    288.81698    288.81698    47060.183    47060.183    616.09552    616.09552 
Loop time of 94.2575 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.917 ns/day, 26.183 hours/ns, 10.609 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 93.273     | 93.273     | 93.273     |   0.0 | 98.96
Neigh   | 0.46094    | 0.46094    | 0.46094    |   0.0 |  0.49
Comm    | 0.091777   | 0.091777   | 0.091777   |   0.0 |  0.10
Output  | 0.00015393 | 0.00015393 | 0.00015393 |   0.0 |  0.00
Modify  | 0.37483    | 0.37483    | 0.37483    |   0.0 |  0.40
Other   |            | 0.05653    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3335.00 ave        3335 max        3335 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119790.0 ave      119790 max      119790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119790
Ave neighs/atom = 59.895000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.386634250088, Press = 0.106369706640459
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000    -3210.224    -3210.224   -3284.8517   -3284.8517    288.81698    288.81698    47060.183    47060.183    616.09552    616.09552 
   75000   -3209.1324   -3209.1324   -3282.9018   -3282.9018    285.49492    285.49492    47224.127    47224.127    44.202725    44.202725 
Loop time of 93.474 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.924 ns/day, 25.965 hours/ns, 10.698 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    | 92.495     | 92.495     | 92.495     |   0.0 | 98.95
Neigh   | 0.46317    | 0.46317    | 0.46317    |   0.0 |  0.50
Comm    | 0.091393   | 0.091393   | 0.091393   |   0.0 |  0.10
Output  | 0.00015354 | 0.00015354 | 0.00015354 |   0.0 |  0.00
Modify  | 0.3687     | 0.3687     | 0.3687     |   0.0 |  0.39
Other   |            | 0.05545    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3332.00 ave        3332 max        3332 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      120034.0 ave      120034 max      120034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 120034
Ave neighs/atom = 60.017000
Neighbor list builds = 22
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.354875252127, Press = 0.919660926412537
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.704 | 3.704 | 3.704 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -3209.1324   -3209.1324   -3282.9018   -3282.9018    285.49492    285.49492    47224.127    47224.127    44.202725    44.202725 
   76000   -3208.5058   -3208.5058   -3281.0855   -3281.0855    280.89067    280.89067     47457.74     47457.74   -288.51218   -288.51218 
Loop time of 92.9413 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.930 ns/day, 25.817 hours/ns, 10.759 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 91.948     | 91.948     | 91.948     |   0.0 | 98.93
Neigh   | 0.48243    | 0.48243    | 0.48243    |   0.0 |  0.52
Comm    | 0.090921   | 0.090921   | 0.090921   |   0.0 |  0.10
Output  | 0.00019018 | 0.00019018 | 0.00019018 |   0.0 |  0.00
Modify  | 0.36446    | 0.36446    | 0.36446    |   0.0 |  0.39
Other   |            | 0.05541    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3362.00 ave        3362 max        3362 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      119014.0 ave      119014 max      119014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119014
Ave neighs/atom = 59.507000
Neighbor list builds = 23
Dangerous builds = 0
if "${V_metal}>${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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
47328.8024399706

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0