# 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.146558970212937*${_u_distance}
variable latticeconst_converted equal 3.146558970212937*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.14655897021294
Lattice spacing in x,y,z = 3.1465590 3.1465590 3.1465590
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 (31.465590 31.465590 31.465590)
  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 (31.465590 31.465590 31.465590)
  create_atoms CPU = 0.005 seconds

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

kim_interactions Mo

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

kim interactions Mo
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_JeongParkDo_2018_PdMo__MO_356501945107_001
pair_coeff * * Mo
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 95.94

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 31153.5559995522 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_356501945107_001#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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -13544.253   -13544.253       -13620       -13620       293.15       293.15    31153.556    31153.556    2597.0328    2597.0328 
    1000   -13466.535   -13466.535    -13550.29    -13550.29    324.14147    324.14147    31319.392    31319.392   -1457.4228   -1457.4228 
Loop time of 112.09 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.771 ns/day, 31.136 hours/ns, 8.921 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.6      | 111.6      | 111.6      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093527   | 0.093527   | 0.093527   |   0.0 |  0.08
Output  | 0.00022882 | 0.00022882 | 0.00022882 |   0.0 |  0.00
Modify  | 0.33687    | 0.33687    | 0.33687    |   0.0 |  0.30
Other   |            | 0.0619     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -13466.535   -13466.535    -13550.29    -13550.29    324.14147    324.14147    31319.392    31319.392   -1457.4228   -1457.4228 
    2000   -13465.242   -13465.242   -13540.836   -13540.836    292.55774    292.55774    31347.211    31347.211    -2273.359    -2273.359 
Loop time of 129.511 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.667 ns/day, 35.975 hours/ns, 7.721 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    | 128.93     | 128.93     | 128.93     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10885    | 0.10885    | 0.10885    |   0.0 |  0.08
Output  | 0.00019147 | 0.00019147 | 0.00019147 |   0.0 |  0.00
Modify  | 0.41092    | 0.41092    | 0.41092    |   0.0 |  0.32
Other   |            | 0.06621    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127984.0 ave      127984 max      127984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127984
Ave neighs/atom = 63.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13465.242   -13465.242   -13540.836   -13540.836    292.55774    292.55774    31347.211    31347.211    -2273.359    -2273.359 
    3000   -13468.503   -13468.503   -13541.907   -13541.907    284.08219    284.08219    31308.838    31308.838     336.6631     336.6631 
Loop time of 123.236 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.701 ns/day, 34.232 hours/ns, 8.115 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.69     | 122.69     | 122.69     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10078    | 0.10078    | 0.10078    |   0.0 |  0.08
Output  | 0.00019382 | 0.00019382 | 0.00019382 |   0.0 |  0.00
Modify  | 0.3795     | 0.3795     | 0.3795     |   0.0 |  0.31
Other   |            | 0.06357    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127986.0 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13468.503   -13468.503   -13541.907   -13541.907    284.08219    284.08219    31308.838    31308.838     336.6631     336.6631 
    4000     -13464.3     -13464.3   -13542.541   -13542.541    302.80252    302.80252     31292.24     31292.24    1900.2412    1900.2412 
Loop time of 129.62 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.667 ns/day, 36.006 hours/ns, 7.715 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    | 129.04     | 129.04     | 129.04     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.108      | 0.108      | 0.108      |   0.0 |  0.08
Output  | 0.00018809 | 0.00018809 | 0.00018809 |   0.0 |  0.00
Modify  | 0.40842    | 0.40842    | 0.40842    |   0.0 |  0.32
Other   |            | 0.06578    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000     -13464.3     -13464.3   -13542.541   -13542.541    302.80252    302.80252     31292.24     31292.24    1900.2412    1900.2412 
    5000   -13468.787   -13468.787   -13541.849   -13541.849     282.7609     282.7609    31300.753    31300.753    803.05732    803.05732 
Loop time of 129.077 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.669 ns/day, 35.855 hours/ns, 7.747 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    | 128.5      | 128.5      | 128.5      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10557    | 0.10557    | 0.10557    |   0.0 |  0.08
Output  | 0.00015782 | 0.00015782 | 0.00015782 |   0.0 |  0.00
Modify  | 0.40905    | 0.40905    | 0.40905    |   0.0 |  0.32
Other   |            | 0.0666     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.373430283781, Press = -222.93344739194
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -13468.787   -13468.787   -13541.849   -13541.849     282.7609     282.7609    31300.753    31300.753    803.05732    803.05732 
    6000   -13464.873   -13464.873   -13543.819   -13543.819     305.5264     305.5264    31337.798    31337.798   -2248.6585   -2248.6585 
Loop time of 119.009 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.058 hours/ns, 8.403 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    | 118.47     | 118.47     | 118.47     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098555   | 0.098555   | 0.098555   |   0.0 |  0.08
Output  | 0.00015411 | 0.00015411 | 0.00015411 |   0.0 |  0.00
Modify  | 0.37584    | 0.37584    | 0.37584    |   0.0 |  0.32
Other   |            | 0.06266    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.364165038737, Press = -18.6597123341767
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13464.873   -13464.873   -13543.819   -13543.819     305.5264     305.5264    31337.798    31337.798   -2248.6585   -2248.6585 
    7000   -13466.422   -13466.422   -13541.647   -13541.647    291.13008    291.13008    31324.479    31324.479   -892.41516   -892.41516 
Loop time of 126.006 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.686 ns/day, 35.002 hours/ns, 7.936 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    | 125.43     | 125.43     | 125.43     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10247    | 0.10247    | 0.10247    |   0.0 |  0.08
Output  | 0.00026106 | 0.00026106 | 0.00026106 |   0.0 |  0.00
Modify  | 0.40949    | 0.40949    | 0.40949    |   0.0 |  0.32
Other   |            | 0.06568    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.73651990075, Press = 12.4195272936722
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13466.422   -13466.422   -13541.647   -13541.647    291.13008    291.13008    31324.479    31324.479   -892.41516   -892.41516 
    8000   -13466.433   -13466.433   -13542.271   -13542.271    293.49979    293.49979    31297.752    31297.752    1202.9815    1202.9815 
Loop time of 131.016 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.659 ns/day, 36.393 hours/ns, 7.633 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    | 130.42     | 130.42     | 130.42     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10559    | 0.10559    | 0.10559    |   0.0 |  0.08
Output  | 0.00015661 | 0.00015661 | 0.00015661 |   0.0 |  0.00
Modify  | 0.42836    | 0.42836    | 0.42836    |   0.0 |  0.33
Other   |            | 0.06623    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127988.0 ave      127988 max      127988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127988
Ave neighs/atom = 63.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.92004303581, Press = 7.15537656472653
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -13466.433   -13466.433   -13542.271   -13542.271    293.49979    293.49979    31297.752    31297.752    1202.9815    1202.9815 
    9000   -13465.356   -13465.356   -13538.496   -13538.496    283.06016    283.06016    31295.803    31295.803    1693.5726    1693.5726 
Loop time of 115.576 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.748 ns/day, 32.104 hours/ns, 8.652 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    | 115.06     | 115.06     | 115.06     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095888   | 0.095888   | 0.095888   |   0.0 |  0.08
Output  | 0.00019155 | 0.00019155 | 0.00019155 |   0.0 |  0.00
Modify  | 0.35797    | 0.35797    | 0.35797    |   0.0 |  0.31
Other   |            | 0.05923    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.914657171193, Press = -3.29317281085307
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13465.356   -13465.356   -13538.496   -13538.496    283.06016    283.06016    31295.803    31295.803    1693.5726    1693.5726 
   10000   -13468.603   -13468.603   -13543.332   -13543.332    289.20894    289.20894    31343.244    31343.244   -2797.7416   -2797.7416 
Loop time of 114.234 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.756 ns/day, 31.732 hours/ns, 8.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    | 113.72     | 113.72     | 113.72     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095208   | 0.095208   | 0.095208   |   0.0 |  0.08
Output  | 0.00015566 | 0.00015566 | 0.00015566 |   0.0 |  0.00
Modify  | 0.35479    | 0.35479    | 0.35479    |   0.0 |  0.31
Other   |            | 0.06008    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127980.0 ave      127980 max      127980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127980
Ave neighs/atom = 63.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.682000753093, Press = -10.5221881186224
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13468.603   -13468.603   -13543.332   -13543.332    289.20894    289.20894    31343.244    31343.244   -2797.7416   -2797.7416 
   11000   -13465.456   -13465.456   -13541.362   -13541.362    293.76641    293.76641    31342.193    31342.193   -2303.8258   -2303.8258 
Loop time of 119.211 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.725 ns/day, 33.114 hours/ns, 8.388 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    | 118.67     | 118.67     | 118.67     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099782   | 0.099782   | 0.099782   |   0.0 |  0.08
Output  | 0.00021792 | 0.00021792 | 0.00021792 |   0.0 |  0.00
Modify  | 0.37672    | 0.37672    | 0.37672    |   0.0 |  0.32
Other   |            | 0.06167    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.342526104845, Press = 7.35914357154977
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -13465.456   -13465.456   -13541.362   -13541.362    293.76641    293.76641    31342.193    31342.193   -2303.8258   -2303.8258 
   12000   -13467.458   -13467.458   -13540.334   -13540.334    282.03898    282.03898    31288.299    31288.299    2197.6452    2197.6452 
Loop time of 130.676 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.661 ns/day, 36.299 hours/ns, 7.653 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.08     | 130.08     | 130.08     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1057     | 0.1057     | 0.1057     |   0.0 |  0.08
Output  | 0.00015465 | 0.00015465 | 0.00015465 |   0.0 |  0.00
Modify  | 0.42566    | 0.42566    | 0.42566    |   0.0 |  0.33
Other   |            | 0.06678    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127984.0 ave      127984 max      127984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127984
Ave neighs/atom = 63.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.341433622123, Press = 5.1783176792573
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13467.458   -13467.458   -13540.334   -13540.334    282.03898    282.03898    31288.299    31288.299    2197.6452    2197.6452 
   13000   -13462.041   -13462.041   -13539.788   -13539.788    300.89001    300.89001    31308.563    31308.563    859.85398    859.85398 
Loop time of 130.619 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.661 ns/day, 36.283 hours/ns, 7.656 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    | 130.02     | 130.02     | 130.02     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10784    | 0.10784    | 0.10784    |   0.0 |  0.08
Output  | 0.00020167 | 0.00020167 | 0.00020167 |   0.0 |  0.00
Modify  | 0.42715    | 0.42715    | 0.42715    |   0.0 |  0.33
Other   |            | 0.06663    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.605799574457, Press = -0.15072226647864
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13462.041   -13462.041   -13539.788   -13539.788    300.89001    300.89001    31308.563    31308.563    859.85398    859.85398 
   14000   -13467.511   -13467.511   -13542.977   -13542.977    292.05919    292.05919    31310.924    31310.924   -89.635941   -89.635941 
Loop time of 123.848 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.698 ns/day, 34.402 hours/ns, 8.074 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.29     | 123.29     | 123.29     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10099    | 0.10099    | 0.10099    |   0.0 |  0.08
Output  | 0.00015275 | 0.00015275 | 0.00015275 |   0.0 |  0.00
Modify  | 0.39572    | 0.39572    | 0.39572    |   0.0 |  0.32
Other   |            | 0.06369    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.747939407281, Press = 1.07130775647163
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13467.511   -13467.511   -13542.977   -13542.977    292.05919    292.05919    31310.924    31310.924   -89.635941   -89.635941 
   15000    -13467.49    -13467.49   -13543.062   -13543.062    292.47095    292.47095    31294.769    31294.769    1409.5466    1409.5466 
Loop time of 126.703 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.682 ns/day, 35.195 hours/ns, 7.892 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.12     | 126.12     | 126.12     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10346    | 0.10346    | 0.10346    |   0.0 |  0.08
Output  | 0.00048324 | 0.00048324 | 0.00048324 |   0.0 |  0.00
Modify  | 0.41005    | 0.41005    | 0.41005    |   0.0 |  0.32
Other   |            | 0.06453    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.708260845513, Press = 1.47057633448139
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000    -13467.49    -13467.49   -13543.062   -13543.062    292.47095    292.47095    31294.769    31294.769    1409.5466    1409.5466 
   16000   -13466.816   -13466.816   -13542.954   -13542.954    294.66152    294.66152    31293.266    31293.266    1536.7954    1536.7954 
Loop time of 122.064 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.708 ns/day, 33.907 hours/ns, 8.192 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    | 121.51     | 121.51     | 121.51     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10087    | 0.10087    | 0.10087    |   0.0 |  0.08
Output  | 0.00021346 | 0.00021346 | 0.00021346 |   0.0 |  0.00
Modify  | 0.39077    | 0.39077    | 0.39077    |   0.0 |  0.32
Other   |            | 0.06213    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127982.0 ave      127982 max      127982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127982
Ave neighs/atom = 63.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.387437161921, Press = -3.826225883137
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13466.816   -13466.816   -13542.954   -13542.954    294.66152    294.66152    31293.266    31293.266    1536.7954    1536.7954 
   17000   -13469.593   -13469.593   -13544.272   -13544.272    289.01489    289.01489    31341.916    31341.916   -2752.6455   -2752.6455 
Loop time of 132.767 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.651 ns/day, 36.880 hours/ns, 7.532 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.15     | 132.15     | 132.15     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1081     | 0.1081     | 0.1081     |   0.0 |  0.08
Output  | 0.00024176 | 0.00024176 | 0.00024176 |   0.0 |  0.00
Modify  | 0.43882    | 0.43882    | 0.43882    |   0.0 |  0.33
Other   |            | 0.0665     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.361001798729, Press = -3.60586936631955
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13469.593   -13469.593   -13544.272   -13544.272    289.01489    289.01489    31341.916    31341.916   -2752.6455   -2752.6455 
   18000   -13465.974   -13465.974   -13541.462   -13541.462    292.14658    292.14658    31336.262    31336.262   -1930.2122   -1930.2122 
Loop time of 129.651 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.666 ns/day, 36.014 hours/ns, 7.713 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    | 129.06     | 129.06     | 129.06     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1052     | 0.1052     | 0.1052     |   0.0 |  0.08
Output  | 0.00015497 | 0.00015497 | 0.00015497 |   0.0 |  0.00
Modify  | 0.42159    | 0.42159    | 0.42159    |   0.0 |  0.33
Other   |            | 0.06596    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.1323552371, Press = 3.6557388894885
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13465.974   -13465.974   -13541.462   -13541.462    292.14658    292.14658    31336.262    31336.262   -1930.2122   -1930.2122 
   19000   -13470.688   -13470.688    -13547.04    -13547.04    295.48761    295.48761    31292.088    31292.088    1094.4033    1094.4033 
Loop time of 121.97 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.708 ns/day, 33.881 hours/ns, 8.199 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    | 121.41     | 121.41     | 121.41     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10064    | 0.10064    | 0.10064    |   0.0 |  0.08
Output  | 0.00018668 | 0.00018668 | 0.00018668 |   0.0 |  0.00
Modify  | 0.39314    | 0.39314    | 0.39314    |   0.0 |  0.32
Other   |            | 0.06395    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127984.0 ave      127984 max      127984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127984
Ave neighs/atom = 63.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.04545603209, Press = 2.21241756985285
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -13470.688   -13470.688    -13547.04    -13547.04    295.48761    295.48761    31292.088    31292.088    1094.4033    1094.4033 
   20000   -13465.456   -13465.456     -13541.8     -13541.8    295.45894    295.45894    31304.967    31304.967    820.10098    820.10098 
Loop time of 118.847 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.727 ns/day, 33.013 hours/ns, 8.414 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    | 118.31     | 118.31     | 118.31     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096802   | 0.096802   | 0.096802   |   0.0 |  0.08
Output  | 0.00015392 | 0.00015392 | 0.00015392 |   0.0 |  0.00
Modify  | 0.37571    | 0.37571    | 0.37571    |   0.0 |  0.32
Other   |            | 0.06232    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.945442734748, Press = -1.39105833098064
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13465.456   -13465.456     -13541.8     -13541.8    295.45894    295.45894    31304.967    31304.967    820.10098    820.10098 
   21000   -13468.904   -13468.904   -13544.563   -13544.563    292.80929    292.80929    31351.943    31351.943   -3515.3088   -3515.3088 
Loop time of 113.255 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.460 hours/ns, 8.830 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    | 112.75     | 112.75     | 112.75     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093643   | 0.093643   | 0.093643   |   0.0 |  0.08
Output  | 0.0001546  | 0.0001546  | 0.0001546  |   0.0 |  0.00
Modify  | 0.35       | 0.35       | 0.35       |   0.0 |  0.31
Other   |            | 0.0598     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.847481675899, Press = -2.67328024205756
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13468.904   -13468.904   -13544.563   -13544.563    292.80929    292.80929    31351.943    31351.943   -3515.3088   -3515.3088 
   22000   -13465.287   -13465.287   -13541.164   -13541.164    293.64989    293.64989    31350.865    31350.865   -3074.3146   -3074.3146 
Loop time of 113.174 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.437 hours/ns, 8.836 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    | 112.67     | 112.67     | 112.67     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094042   | 0.094042   | 0.094042   |   0.0 |  0.08
Output  | 0.00015385 | 0.00015385 | 0.00015385 |   0.0 |  0.00
Modify  | 0.34797    | 0.34797    | 0.34797    |   0.0 |  0.31
Other   |            | 0.06036    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.881012784452, Press = 4.60596012860878
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13465.287   -13465.287   -13541.164   -13541.164    293.64989    293.64989    31350.865    31350.865   -3074.3146   -3074.3146 
   23000     -13467.9     -13467.9   -13543.224   -13543.224    291.51514    291.51514     31286.95     31286.95    1972.8669    1972.8669 
Loop time of 117.437 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.736 ns/day, 32.621 hours/ns, 8.515 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    | 116.91     | 116.91     | 116.91     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09713    | 0.09713    | 0.09713    |   0.0 |  0.08
Output  | 0.00015466 | 0.00015466 | 0.00015466 |   0.0 |  0.00
Modify  | 0.37041    | 0.37041    | 0.37041    |   0.0 |  0.32
Other   |            | 0.06174    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127988.0 ave      127988 max      127988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127988
Ave neighs/atom = 63.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.85535323928, Press = 2.00148470173299
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000     -13467.9     -13467.9   -13543.224   -13543.224    291.51514    291.51514     31286.95     31286.95    1972.8669    1972.8669 
   24000   -13466.551   -13466.551   -13542.317   -13542.317    293.22394    293.22394    31299.461    31299.461    1103.6429    1103.6429 
Loop time of 132.311 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.653 ns/day, 36.753 hours/ns, 7.558 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.7      | 131.7      | 131.7      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10847    | 0.10847    | 0.10847    |   0.0 |  0.08
Output  | 0.0001547  | 0.0001547  | 0.0001547  |   0.0 |  0.00
Modify  | 0.43806    | 0.43806    | 0.43806    |   0.0 |  0.33
Other   |            | 0.06681    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.857688066547, Press = -0.915924017362415
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13466.551   -13466.551   -13542.317   -13542.317    293.22394    293.22394    31299.461    31299.461    1103.6429    1103.6429 
   25000   -13468.653   -13468.653   -13542.258   -13542.258    284.86197    284.86197     31327.79     31327.79   -1258.5964   -1258.5964 
Loop time of 132.649 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.651 ns/day, 36.847 hours/ns, 7.539 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.04     | 132.04     | 132.04     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10794    | 0.10794    | 0.10794    |   0.0 |  0.08
Output  | 0.00021619 | 0.00021619 | 0.00021619 |   0.0 |  0.00
Modify  | 0.43665    | 0.43665    | 0.43665    |   0.0 |  0.33
Other   |            | 0.06718    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127988.0 ave      127988 max      127988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127988
Ave neighs/atom = 63.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.723895322007, Press = -0.762409481883324
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13468.653   -13468.653   -13542.258   -13542.258    284.86197    284.86197     31327.79     31327.79   -1258.5964   -1258.5964 
   26000   -13468.607   -13468.607   -13543.194   -13543.194    288.65873    288.65873    31332.299    31332.299   -1741.7555   -1741.7555 
Loop time of 130.978 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.660 ns/day, 36.383 hours/ns, 7.635 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    | 130.37     | 130.37     | 130.37     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10655    | 0.10655    | 0.10655    |   0.0 |  0.08
Output  | 0.00018344 | 0.00018344 | 0.00018344 |   0.0 |  0.00
Modify  | 0.43256    | 0.43256    | 0.43256    |   0.0 |  0.33
Other   |            | 0.06658    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127986.0 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.752859763002, Press = 2.31784584817508
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13468.607   -13468.607   -13543.194   -13543.194    288.65873    288.65873    31332.299    31332.299   -1741.7555   -1741.7555 
   27000   -13466.783   -13466.783   -13541.939   -13541.939    290.86378    290.86378    31254.934    31254.934    4906.7035    4906.7035 
Loop time of 127.011 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.680 ns/day, 35.281 hours/ns, 7.873 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    | 126.43     | 126.43     | 126.43     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10486    | 0.10486    | 0.10486    |   0.0 |  0.08
Output  | 0.0001547  | 0.0001547  | 0.0001547  |   0.0 |  0.00
Modify  | 0.41121    | 0.41121    | 0.41121    |   0.0 |  0.32
Other   |            | 0.06497    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.773752042831, Press = 3.10495739122219
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13466.783   -13466.783   -13541.939   -13541.939    290.86378    290.86378    31254.934    31254.934    4906.7035    4906.7035 
   28000   -13466.254   -13466.254   -13541.822   -13541.822    292.45747    292.45747    31297.072    31297.072    1205.8572    1205.8572 
Loop time of 129.413 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.668 ns/day, 35.948 hours/ns, 7.727 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.81     | 128.81     | 128.81     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10583    | 0.10583    | 0.10583    |   0.0 |  0.08
Output  | 0.00019274 | 0.00019274 | 0.00019274 |   0.0 |  0.00
Modify  | 0.42643    | 0.42643    | 0.42643    |   0.0 |  0.33
Other   |            | 0.06639    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.80013753467, Press = -0.880003473927847
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13466.254   -13466.254   -13541.822   -13541.822    292.45747    292.45747    31297.072    31297.072    1205.8572    1205.8572 
   29000   -13471.245   -13471.245    -13544.47    -13544.47    283.38688    283.38688    31326.718    31326.718   -1667.1174   -1667.1174 
Loop time of 129.075 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.669 ns/day, 35.854 hours/ns, 7.747 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    | 128.47     | 128.47     | 128.47     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10654    | 0.10654    | 0.10654    |   0.0 |  0.08
Output  | 0.0002058  | 0.0002058  | 0.0002058  |   0.0 |  0.00
Modify  | 0.42928    | 0.42928    | 0.42928    |   0.0 |  0.33
Other   |            | 0.06573    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.738846040488, Press = 0.0128711920170487
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13471.245   -13471.245    -13544.47    -13544.47    283.38688    283.38688    31326.718    31326.718   -1667.1174   -1667.1174 
   30000    -13464.47    -13464.47    -13543.23    -13543.23    304.81158    304.81158    31326.856    31326.856   -1135.4278   -1135.4278 
Loop time of 121.062 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.628 hours/ns, 8.260 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    | 120.51     | 120.51     | 120.51     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09997    | 0.09997    | 0.09997    |   0.0 |  0.08
Output  | 0.00019232 | 0.00019232 | 0.00019232 |   0.0 |  0.00
Modify  | 0.38962    | 0.38962    | 0.38962    |   0.0 |  0.32
Other   |            | 0.06255    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.689848163148, Press = 1.31314072761139
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000    -13464.47    -13464.47    -13543.23    -13543.23    304.81158    304.81158    31326.856    31326.856   -1135.4278   -1135.4278 
   31000   -13467.842   -13467.842   -13542.973   -13542.973    290.76479    290.76479    31289.656    31289.656    1766.3705    1766.3705 
Loop time of 117.115 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.738 ns/day, 32.532 hours/ns, 8.539 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.59     | 116.59     | 116.59     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096275   | 0.096275   | 0.096275   |   0.0 |  0.08
Output  | 0.00015364 | 0.00015364 | 0.00015364 |   0.0 |  0.00
Modify  | 0.36622    | 0.36622    | 0.36622    |   0.0 |  0.31
Other   |            | 0.0611     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.67527010781, Press = 1.73370146028609
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -13467.842   -13467.842   -13542.973   -13542.973    290.76479    290.76479    31289.656    31289.656    1766.3705    1766.3705 
   32000   -13464.133   -13464.133    -13542.61    -13542.61    303.71469    303.71469    31274.348    31274.348    3200.5577    3200.5577 
Loop time of 113.488 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.525 hours/ns, 8.811 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    | 112.98     | 112.98     | 112.98     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09386    | 0.09386    | 0.09386    |   0.0 |  0.08
Output  | 0.00015619 | 0.00015619 | 0.00015619 |   0.0 |  0.00
Modify  | 0.35081    | 0.35081    | 0.35081    |   0.0 |  0.31
Other   |            | 0.05944    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127986.0 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.679240530144, Press = -1.00055918069565
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13464.133   -13464.133    -13542.61    -13542.61    303.71469    303.71469    31274.348    31274.348    3200.5577    3200.5577 
   33000   -13468.907   -13468.907   -13543.938   -13543.938    290.37869    290.37869    31339.186    31339.186   -2616.7266   -2616.7266 
Loop time of 114.479 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.755 ns/day, 31.800 hours/ns, 8.735 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.97     | 113.97     | 113.97     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094607   | 0.094607   | 0.094607   |   0.0 |  0.08
Output  | 0.00015604 | 0.00015604 | 0.00015604 |   0.0 |  0.00
Modify  | 0.35504    | 0.35504    | 0.35504    |   0.0 |  0.31
Other   |            | 0.06059    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.671740408901, Press = -1.59280502482215
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -13468.907   -13468.907   -13543.938   -13543.938    290.37869    290.37869    31339.186    31339.186   -2616.7266   -2616.7266 
   34000   -13465.696   -13465.696   -13541.669   -13541.669    294.02118    294.02118    31333.446    31333.446   -1695.8081   -1695.8081 
Loop time of 132.316 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.653 ns/day, 36.754 hours/ns, 7.558 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.71     | 131.71     | 131.71     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10756    | 0.10756    | 0.10756    |   0.0 |  0.08
Output  | 0.00019192 | 0.00019192 | 0.00019192 |   0.0 |  0.00
Modify  | 0.43494    | 0.43494    | 0.43494    |   0.0 |  0.33
Other   |            | 0.06714    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127986.0 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.629751848533, Press = 1.25597427978763
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -13465.696   -13465.696   -13541.669   -13541.669    294.02118    294.02118    31333.446    31333.446   -1695.8081   -1695.8081 
   35000   -13470.641   -13470.641   -13542.865   -13542.865    279.51479    279.51479    31291.025    31291.025    1451.0519    1451.0519 
Loop time of 132.269 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.653 ns/day, 36.741 hours/ns, 7.560 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.66     | 131.66     | 131.66     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10768    | 0.10768    | 0.10768    |   0.0 |  0.08
Output  | 0.00015448 | 0.00015448 | 0.00015448 |   0.0 |  0.00
Modify  | 0.4361     | 0.4361     | 0.4361     |   0.0 |  0.33
Other   |            | 0.06701    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.570465555795, Press = 1.65763945460076
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13470.641   -13470.641   -13542.865   -13542.865    279.51479    279.51479    31291.025    31291.025    1451.0519    1451.0519 
   36000   -13467.573   -13467.573   -13543.557   -13543.557    294.06309    294.06309    31290.772    31290.772    1605.2281    1605.2281 
Loop time of 129.998 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.665 ns/day, 36.111 hours/ns, 7.692 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    | 129.4      | 129.4      | 129.4      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10602    | 0.10602    | 0.10602    |   0.0 |  0.08
Output  | 0.00015583 | 0.00015583 | 0.00015583 |   0.0 |  0.00
Modify  | 0.42503    | 0.42503    | 0.42503    |   0.0 |  0.33
Other   |            | 0.06609    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.591003307443, Press = -0.0531965974110293
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -13467.573   -13467.573   -13543.557   -13543.557    294.06309    294.06309    31290.772    31290.772    1605.2281    1605.2281 
   37000   -13462.757   -13462.757   -13540.204   -13540.204    299.72901    299.72901    31337.222    31337.222   -1843.6857   -1843.6857 
Loop time of 131.978 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.655 ns/day, 36.661 hours/ns, 7.577 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    | 131.36     | 131.36     | 131.36     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10816    | 0.10816    | 0.10816    |   0.0 |  0.08
Output  | 0.00017226 | 0.00017226 | 0.00017226 |   0.0 |  0.00
Modify  | 0.43727    | 0.43727    | 0.43727    |   0.0 |  0.33
Other   |            | 0.06748    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.652528481303, Press = -1.06467713756157
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -13462.757   -13462.757   -13540.204   -13540.204    299.72901    299.72901    31337.222    31337.222   -1843.6857   -1843.6857 
   38000   -13467.131   -13467.131   -13543.145   -13543.145    294.17995    294.17995    31357.741    31357.741   -3998.7913   -3998.7913 
Loop time of 119.667 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.722 ns/day, 33.241 hours/ns, 8.356 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    | 119.13     | 119.13     | 119.13     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098449   | 0.098449   | 0.098449   |   0.0 |  0.08
Output  | 0.00019543 | 0.00019543 | 0.00019543 |   0.0 |  0.00
Modify  | 0.37927    | 0.37927    | 0.37927    |   0.0 |  0.32
Other   |            | 0.06258    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127988.0 ave      127988 max      127988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127988
Ave neighs/atom = 63.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.719775649392, Press = 1.5872475494199
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -13467.131   -13467.131   -13543.145   -13543.145    294.17995    294.17995    31357.741    31357.741   -3998.7913   -3998.7913 
   39000   -13462.491   -13462.491   -13540.681   -13540.681    302.60241    302.60241    31296.684    31296.684     1535.113     1535.113 
Loop time of 120.634 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.716 ns/day, 33.510 hours/ns, 8.290 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    | 120.09     | 120.09     | 120.09     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099645   | 0.099645   | 0.099645   |   0.0 |  0.08
Output  | 0.00015978 | 0.00015978 | 0.00015978 |   0.0 |  0.00
Modify  | 0.38446    | 0.38446    | 0.38446    |   0.0 |  0.32
Other   |            | 0.06354    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.813165907537, Press = 1.77803325234375
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -13462.491   -13462.491   -13540.681   -13540.681    302.60241    302.60241    31296.684    31296.684     1535.113     1535.113 
   40000   -13465.918   -13465.918   -13543.612   -13543.612    300.68453    300.68453    31301.726    31301.726    727.85015    727.85015 
Loop time of 114.248 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.756 ns/day, 31.736 hours/ns, 8.753 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    | 113.74     | 113.74     | 113.74     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094561   | 0.094561   | 0.094561   |   0.0 |  0.08
Output  | 0.00015613 | 0.00015613 | 0.00015613 |   0.0 |  0.00
Modify  | 0.35353    | 0.35353    | 0.35353    |   0.0 |  0.31
Other   |            | 0.05959    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.837161874986, Press = 0.00105922694946186
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -13465.918   -13465.918   -13543.612   -13543.612    300.68453    300.68453    31301.726    31301.726    727.85015    727.85015 
   41000   -13467.038   -13467.038    -13542.42    -13542.42    291.73762    291.73762    31320.985    31320.985   -766.57538   -766.57538 
Loop time of 113.38 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.494 hours/ns, 8.820 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    | 112.88     | 112.88     | 112.88     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094553   | 0.094553   | 0.094553   |   0.0 |  0.08
Output  | 0.00045339 | 0.00045339 | 0.00045339 |   0.0 |  0.00
Modify  | 0.34898    | 0.34898    | 0.34898    |   0.0 |  0.31
Other   |            | 0.05901    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.852897714246, Press = -0.145604385829311
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -13467.038   -13467.038    -13542.42    -13542.42    291.73762    291.73762    31320.985    31320.985   -766.57538   -766.57538 
   42000   -13464.152   -13464.152   -13541.241   -13541.241    298.34147    298.34147    31333.235    31333.235   -1784.6262   -1784.6262 
Loop time of 113.469 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.519 hours/ns, 8.813 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    | 112.97     | 112.97     | 112.97     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094176   | 0.094176   | 0.094176   |   0.0 |  0.08
Output  | 0.0001877  | 0.0001877  | 0.0001877  |   0.0 |  0.00
Modify  | 0.34935    | 0.34935    | 0.34935    |   0.0 |  0.31
Other   |            | 0.05897    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127988.0 ave      127988 max      127988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127988
Ave neighs/atom = 63.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.900927654293, Press = 0.772323104798044
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -13464.152   -13464.152   -13541.241   -13541.241    298.34147    298.34147    31333.235    31333.235   -1784.6262   -1784.6262 
   43000   -13468.341   -13468.341   -13542.599   -13542.599    287.38595    287.38595    31290.126    31290.126    1727.9526    1727.9526 
Loop time of 113.78 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.759 ns/day, 31.605 hours/ns, 8.789 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    | 113.27     | 113.27     | 113.27     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094436   | 0.094436   | 0.094436   |   0.0 |  0.08
Output  | 0.00020292 | 0.00020292 | 0.00020292 |   0.0 |  0.00
Modify  | 0.35207    | 0.35207    | 0.35207    |   0.0 |  0.31
Other   |            | 0.0591     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127982.0 ave      127982 max      127982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127982
Ave neighs/atom = 63.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.972692164855, Press = 1.53938043523082
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -13468.341   -13468.341   -13542.599   -13542.599    287.38595    287.38595    31290.126    31290.126    1727.9526    1727.9526 
   44000   -13464.867   -13464.867   -13541.653   -13541.653    297.16833    297.16833     31276.51     31276.51    3218.1742    3218.1742 
Loop time of 132.27 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.653 ns/day, 36.742 hours/ns, 7.560 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.66     | 131.66     | 131.66     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10717    | 0.10717    | 0.10717    |   0.0 |  0.08
Output  | 0.00020087 | 0.00020087 | 0.00020087 |   0.0 |  0.00
Modify  | 0.4383     | 0.4383     | 0.4383     |   0.0 |  0.33
Other   |            | 0.06649    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127986.0 ave      127986 max      127986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127986
Ave neighs/atom = 63.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.98354806468, Press = -0.458620302338635
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -13464.867   -13464.867   -13541.653   -13541.653    297.16833    297.16833     31276.51     31276.51    3218.1742    3218.1742 
   45000   -13467.693   -13467.693   -13542.505   -13542.505    289.52988    289.52988    31332.256    31332.256   -1604.8333   -1604.8333 
Loop time of 117.132 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.738 ns/day, 32.537 hours/ns, 8.537 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 116.6      | 116.6      | 116.6      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096519   | 0.096519   | 0.096519   |   0.0 |  0.08
Output  | 0.00015785 | 0.00015785 | 0.00015785 |   0.0 |  0.00
Modify  | 0.36953    | 0.36953    | 0.36953    |   0.0 |  0.32
Other   |            | 0.06145    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.027239569269, Press = -0.816579795243389
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -13467.693   -13467.693   -13542.505   -13542.505    289.52988    289.52988    31332.256    31332.256   -1604.8333   -1604.8333 
   46000   -13463.509   -13463.509   -13540.438   -13540.438    297.72429    297.72429    31334.705    31334.705   -1494.3886   -1494.3886 
Loop time of 113.981 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.758 ns/day, 31.661 hours/ns, 8.773 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    | 113.48     | 113.48     | 113.48     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094393   | 0.094393   | 0.094393   |   0.0 |  0.08
Output  | 0.00015473 | 0.00015473 | 0.00015473 |   0.0 |  0.00
Modify  | 0.35126    | 0.35126    | 0.35126    |   0.0 |  0.31
Other   |            | 0.05998    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127988.0 ave      127988 max      127988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127988
Ave neighs/atom = 63.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.091122394307, Press = 0.697801508134108
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -13463.509   -13463.509   -13540.438   -13540.438    297.72429    297.72429    31334.705    31334.705   -1494.3886   -1494.3886 
   47000   -13465.379   -13465.379    -13540.82    -13540.82    291.96231    291.96231    31309.471    31309.471    721.20781    721.20781 
Loop time of 113.799 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.759 ns/day, 31.611 hours/ns, 8.787 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    | 113.3      | 113.3      | 113.3      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094335   | 0.094335   | 0.094335   |   0.0 |  0.08
Output  | 0.00015496 | 0.00015496 | 0.00015496 |   0.0 |  0.00
Modify  | 0.34939    | 0.34939    | 0.34939    |   0.0 |  0.31
Other   |            | 0.0597     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127988.0 ave      127988 max      127988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127988
Ave neighs/atom = 63.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.100181140603, Press = 0.788774752591182
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -13465.379   -13465.379    -13540.82    -13540.82    291.96231    291.96231    31309.471    31309.471    721.20781    721.20781 
   48000   -13470.587   -13470.587   -13543.864   -13543.864    283.59203    283.59203    31288.893    31288.893    1746.0759    1746.0759 
Loop time of 113.46 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.517 hours/ns, 8.814 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.96     | 112.96     | 112.96     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094299   | 0.094299   | 0.094299   |   0.0 |  0.08
Output  | 0.00015665 | 0.00015665 | 0.00015665 |   0.0 |  0.00
Modify  | 0.34994    | 0.34994    | 0.34994    |   0.0 |  0.31
Other   |            | 0.05973    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127988.0 ave      127988 max      127988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127988
Ave neighs/atom = 63.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.073622064801, Press = 0.227231246174065
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -13470.587   -13470.587   -13543.864   -13543.864    283.59203    283.59203    31288.893    31288.893    1746.0759    1746.0759 
   49000   -13466.721   -13466.721   -13541.596   -13541.596    289.77191    289.77191    31333.503    31333.503   -1647.4418   -1647.4418 
Loop time of 113.457 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.516 hours/ns, 8.814 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.95     | 112.95     | 112.95     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094259   | 0.094259   | 0.094259   |   0.0 |  0.08
Output  | 0.00018988 | 0.00018988 | 0.00018988 |   0.0 |  0.00
Modify  | 0.34877    | 0.34877    | 0.34877    |   0.0 |  0.31
Other   |            | 0.06054    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.035935515494, Press = -1.04054146954745
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -13466.721   -13466.721   -13541.596   -13541.596    289.77191    289.77191    31333.503    31333.503   -1647.4418   -1647.4418 
   50000   -13467.954   -13467.954   -13543.312   -13543.312    291.64237    291.64237    31355.576    31355.576   -3766.0542   -3766.0542 
Loop time of 113.434 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.509 hours/ns, 8.816 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.93     | 112.93     | 112.93     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094441   | 0.094441   | 0.094441   |   0.0 |  0.08
Output  | 0.00015737 | 0.00015737 | 0.00015737 |   0.0 |  0.00
Modify  | 0.34901    | 0.34901    | 0.34901    |   0.0 |  0.31
Other   |            | 0.06038    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.97960311136, Press = 0.748302295483089
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -13467.954   -13467.954   -13543.312   -13543.312    291.64237    291.64237    31355.576    31355.576   -3766.0542   -3766.0542 
   51000   -13467.882   -13467.882   -13543.212   -13543.212    291.53333    291.53333    31299.412    31299.412    1024.0961    1024.0961 
Loop time of 113.967 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.758 ns/day, 31.658 hours/ns, 8.774 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    | 113.46     | 113.46     | 113.46     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094938   | 0.094938   | 0.094938   |   0.0 |  0.08
Output  | 0.00015664 | 0.00015664 | 0.00015664 |   0.0 |  0.00
Modify  | 0.35304    | 0.35304    | 0.35304    |   0.0 |  0.31
Other   |            | 0.06002    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.990379726715, Press = 1.21145179073
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -13467.882   -13467.882   -13543.212   -13543.212    291.53333    291.53333    31299.412    31299.412    1024.0961    1024.0961 
   52000   -13464.345   -13464.345   -13541.534   -13541.534    298.72854    298.72854    31302.233    31302.233    1224.8955    1224.8955 
Loop time of 118.228 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.731 ns/day, 32.841 hours/ns, 8.458 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 117.7      | 117.7      | 117.7      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097621   | 0.097621   | 0.097621   |   0.0 |  0.08
Output  | 0.00018842 | 0.00018842 | 0.00018842 |   0.0 |  0.00
Modify  | 0.3733     | 0.3733     | 0.3733     |   0.0 |  0.32
Other   |            | 0.06138    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127998.0 ave      127998 max      127998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127998
Ave neighs/atom = 63.999000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.027568250296, Press = 0.321459698531368
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -13464.345   -13464.345   -13541.534   -13541.534    298.72854    298.72854    31302.233    31302.233    1224.8955    1224.8955 
   53000   -13467.623   -13467.623   -13543.805   -13543.805    294.83347    294.83347    31322.153    31322.153   -850.66846   -850.66846 
Loop time of 128.014 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.675 ns/day, 35.559 hours/ns, 7.812 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    | 127.42     | 127.42     | 127.42     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1052     | 0.1052     | 0.1052     |   0.0 |  0.08
Output  | 0.00019875 | 0.00019875 | 0.00019875 |   0.0 |  0.00
Modify  | 0.42105    | 0.42105    | 0.42105    |   0.0 |  0.33
Other   |            | 0.06617    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.023552417938, Press = 0.230724999193794
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -13467.623   -13467.623   -13543.805   -13543.805    294.83347    294.83347    31322.153    31322.153   -850.66846   -850.66846 
   54000   -13465.294   -13465.294   -13541.655   -13541.655    295.52727    295.52727     31316.19     31316.19   -233.02948   -233.02948 
Loop time of 132.631 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.651 ns/day, 36.842 hours/ns, 7.540 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.01     | 132.01     | 132.01     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10914    | 0.10914    | 0.10914    |   0.0 |  0.08
Output  | 0.00015599 | 0.00015599 | 0.00015599 |   0.0 |  0.00
Modify  | 0.44073    | 0.44073    | 0.44073    |   0.0 |  0.33
Other   |            | 0.06708    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.990794963916, Press = 0.512990694861576
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -13465.294   -13465.294   -13541.655   -13541.655    295.52727    295.52727     31316.19     31316.19   -233.02948   -233.02948 
   55000   -13471.999   -13471.999   -13545.657   -13545.657     285.0647     285.0647    31297.092    31297.092    849.07939    849.07939 
Loop time of 129.681 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.666 ns/day, 36.023 hours/ns, 7.711 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    | 129.08     | 129.08     | 129.08     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10683    | 0.10683    | 0.10683    |   0.0 |  0.08
Output  | 0.00021774 | 0.00021774 | 0.00021774 |   0.0 |  0.00
Modify  | 0.42694    | 0.42694    | 0.42694    |   0.0 |  0.33
Other   |            | 0.06641    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127990.0 ave      127990 max      127990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127990
Ave neighs/atom = 63.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.949914048697, Press = 0.248110828760526
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -13471.999   -13471.999   -13545.657   -13545.657     285.0647     285.0647    31297.092    31297.092    849.07939    849.07939 
   56000   -13466.554   -13466.554   -13543.808   -13543.808    298.98317    298.98317    31311.911    31311.911    8.6861622    8.6861622 
Loop time of 132.453 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.652 ns/day, 36.793 hours/ns, 7.550 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    | 131.84     | 131.84     | 131.84     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10823    | 0.10823    | 0.10823    |   0.0 |  0.08
Output  | 0.00015488 | 0.00015488 | 0.00015488 |   0.0 |  0.00
Modify  | 0.43943    | 0.43943    | 0.43943    |   0.0 |  0.33
Other   |            | 0.0674     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127992.0 ave      127992 max      127992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127992
Ave neighs/atom = 63.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.93435730062, Press = -0.186372261504949
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -13466.554   -13466.554   -13543.808   -13543.808    298.98317    298.98317    31311.911    31311.911    8.6861622    8.6861622 
   57000   -13462.445   -13462.445   -13538.198   -13538.198    293.17325    293.17325    31350.649    31350.649   -2561.1329   -2561.1329 
Loop time of 130.363 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.663 ns/day, 36.212 hours/ns, 7.671 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    | 129.75     | 129.75     | 129.75     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10821    | 0.10821    | 0.10821    |   0.0 |  0.08
Output  | 0.00015652 | 0.00015652 | 0.00015652 |   0.0 |  0.00
Modify  | 0.43431    | 0.43431    | 0.43431    |   0.0 |  0.33
Other   |            | 0.06672    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127984.0 ave      127984 max      127984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127984
Ave neighs/atom = 63.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.945316067454, Press = 0.0978023805801437
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -13462.445   -13462.445   -13538.198   -13538.198    293.17325    293.17325    31350.649    31350.649   -2561.1329   -2561.1329 
   58000    -13466.61    -13466.61   -13543.154   -13543.154     296.2316     296.2316    31318.057    31318.057   -408.88312   -408.88312 
Loop time of 132.26 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.653 ns/day, 36.739 hours/ns, 7.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    | 131.65     | 131.65     | 131.65     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1079     | 0.1079     | 0.1079     |   0.0 |  0.08
Output  | 0.0001987  | 0.0001987  | 0.0001987  |   0.0 |  0.00
Modify  | 0.43838    | 0.43838    | 0.43838    |   0.0 |  0.33
Other   |            | 0.06773    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.013654078587, Press = 1.51888482438679
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000    -13466.61    -13466.61   -13543.154   -13543.154     296.2316     296.2316    31318.057    31318.057   -408.88312   -408.88312 
   59000   -13467.058   -13467.058   -13542.413   -13542.413    291.63225    291.63225    31275.681    31275.681    3161.3805    3161.3805 
Loop time of 122.987 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.703 ns/day, 34.163 hours/ns, 8.131 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    | 122.43     | 122.43     | 122.43     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10187    | 0.10187    | 0.10187    |   0.0 |  0.08
Output  | 0.00015752 | 0.00015752 | 0.00015752 |   0.0 |  0.00
Modify  | 0.39388    | 0.39388    | 0.39388    |   0.0 |  0.32
Other   |            | 0.06332    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127996
Ave neighs/atom = 63.998000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.005028956544, Press = 0.530429788186228
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -13467.058   -13467.058   -13542.413   -13542.413    291.63225    291.63225    31275.681    31275.681    3161.3805    3161.3805 
   60000   -13467.803   -13467.803   -13543.643   -13543.643     293.5089     293.5089    31312.012    31312.012    79.948622    79.948622 
Loop time of 127.99 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.675 ns/day, 35.553 hours/ns, 7.813 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    | 127.4      | 127.4      | 127.4      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10386    | 0.10386    | 0.10386    |   0.0 |  0.08
Output  | 0.00021402 | 0.00021402 | 0.00021402 |   0.0 |  0.00
Modify  | 0.41584    | 0.41584    | 0.41584    |   0.0 |  0.32
Other   |            | 0.06556    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127994.0 ave      127994 max      127994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 127994
Ave neighs/atom = 63.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.005586931938, Press = -0.569674082087158
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -13467.803   -13467.803   -13543.643   -13543.643     293.5089     293.5089    31312.012    31312.012    79.948622    79.948622 
   61000   -13466.319   -13466.319   -13542.913   -13542.913    296.42499    296.42499    31335.853    31335.853   -2010.5947   -2010.5947 
Loop time of 130.706 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.661 ns/day, 36.307 hours/ns, 7.651 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    | 130.1      | 130.1      | 130.1      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10681    | 0.10681    | 0.10681    |   0.0 |  0.08
Output  | 0.00019965 | 0.00019965 | 0.00019965 |   0.0 |  0.00
Modify  | 0.43104    | 0.43104    | 0.43104    |   0.0 |  0.33
Other   |            | 0.06635    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      127996.0 ave      127996 max      127996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0