# 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.1465589627623562*${_u_distance}
variable latticeconst_converted equal 3.1465589627623562*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.14655896276236
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.003 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_WangOhLee_2020_CuMo__MO_486450342170_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.5557782513    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 31153.5557782513/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 31153.5557782513/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 31153.5557782513/(1*1*${_u_distance})
variable      V0_metal equal 31153.5557782513/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 31153.5557782513*1000

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_486450342170_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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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    -13549.42    -13549.42       -13620       -13620       273.15       273.15    31153.556    31153.556    2419.8695    2419.8695 
    1000    -13477.19    -13477.19   -13555.159   -13555.159    301.74637    301.74637    31261.825    31261.825    2457.9577    2457.9577 
Loop time of 125.595 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.688 ns/day, 34.888 hours/ns, 7.962 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.04     | 125.04     | 125.04     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10371    | 0.10371    | 0.10371    |   0.0 |  0.08
Output  | 0.00022404 | 0.00022404 | 0.00022404 |   0.0 |  0.00
Modify  | 0.38421    | 0.38421    | 0.38421    |   0.0 |  0.31
Other   |            | 0.06283    |            |       |  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:      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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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    -13477.19    -13477.19   -13555.159   -13555.159    301.74637    301.74637    31261.825    31261.825    2457.9577    2457.9577 
    2000   -13475.798   -13475.798   -13547.037   -13547.037    275.70329    275.70329    31271.943    31271.943    2975.2488    2975.2488 
Loop time of 119.891 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.721 ns/day, 33.303 hours/ns, 8.341 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.4      | 119.4      | 119.4      |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097631   | 0.097631   | 0.097631   |   0.0 |  0.08
Output  | 0.00019396 | 0.00019396 | 0.00019396 |   0.0 |  0.00
Modify  | 0.3344     | 0.3344     | 0.3344     |   0.0 |  0.28
Other   |            | 0.05775    |            |       |  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:      133752.0 ave      133752 max      133752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133752
Ave neighs/atom = 66.876000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13475.798   -13475.798   -13547.037   -13547.037    275.70329    275.70329    31271.943    31271.943    2975.2488    2975.2488 
    3000   -13478.957   -13478.957   -13547.341   -13547.341    264.65222    264.65222    31278.949    31278.949    1881.5975    1881.5975 
Loop time of 119.643 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.722 ns/day, 33.234 hours/ns, 8.358 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.15     | 119.15     | 119.15     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097242   | 0.097242   | 0.097242   |   0.0 |  0.08
Output  | 0.00019076 | 0.00019076 | 0.00019076 |   0.0 |  0.00
Modify  | 0.33438    | 0.33438    | 0.33438    |   0.0 |  0.28
Other   |            | 0.0572     |            |       |  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:      134246.0 ave      134246 max      134246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134246
Ave neighs/atom = 67.123000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13478.957   -13478.957   -13547.341   -13547.341    264.65222    264.65222    31278.949    31278.949    1881.5975    1881.5975 
    4000   -13475.231   -13475.231   -13545.016   -13545.016    270.07625    270.07625    31291.288    31291.288    1163.3165    1163.3165 
Loop time of 134.651 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.642 ns/day, 37.403 hours/ns, 7.427 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    | 134.08     | 134.08     | 134.08     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10549    | 0.10549    | 0.10549    |   0.0 |  0.08
Output  | 0.00019125 | 0.00019125 | 0.00019125 |   0.0 |  0.00
Modify  | 0.39805    | 0.39805    | 0.39805    |   0.0 |  0.30
Other   |            | 0.0643     |            |       |  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:      134238.0 ave      134238 max      134238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134238
Ave neighs/atom = 67.119000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13475.231   -13475.231   -13545.016   -13545.016    270.07625    270.07625    31291.288    31291.288    1163.3165    1163.3165 
    5000   -13479.371   -13479.371   -13546.566   -13546.566    260.05428    260.05428    31287.275    31287.275    953.39457    953.39457 
Loop time of 139.627 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.619 ns/day, 38.785 hours/ns, 7.162 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    | 139.03     | 139.03     | 139.03     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10822    | 0.10822    | 0.10822    |   0.0 |  0.08
Output  | 0.00015993 | 0.00015993 | 0.00015993 |   0.0 |  0.00
Modify  | 0.41991    | 0.41991    | 0.41991    |   0.0 |  0.30
Other   |            | 0.0671     |            |       |  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:      134504.0 ave      134504 max      134504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134504
Ave neighs/atom = 67.252000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.445955057633, Press = -18.3820695302933
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13479.371   -13479.371   -13546.566   -13546.566    260.05428    260.05428    31287.275    31287.275    953.39457    953.39457 
    6000     -13475.5     -13475.5   -13549.993   -13549.993    288.29517    288.29517    31283.443    31283.443    1266.9356    1266.9356 
Loop time of 131.791 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.656 ns/day, 36.609 hours/ns, 7.588 timesteps/s
99.9% 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.22     | 131.22     | 131.22     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10235    | 0.10235    | 0.10235    |   0.0 |  0.08
Output  | 0.00019451 | 0.00019451 | 0.00019451 |   0.0 |  0.00
Modify  | 0.40293    | 0.40293    | 0.40293    |   0.0 |  0.31
Other   |            | 0.06389    |            |       |  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:      134590.0 ave      134590 max      134590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134590
Ave neighs/atom = 67.295000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.641695700588, Press = 18.4353535458035
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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     -13475.5     -13475.5   -13549.993   -13549.993    288.29517    288.29517    31283.443    31283.443    1266.9356    1266.9356 
    7000   -13477.173   -13477.173   -13546.591   -13546.591    268.65234    268.65234    31293.197    31293.197    751.96953    751.96953 
Loop time of 122.448 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.706 ns/day, 34.013 hours/ns, 8.167 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.93     | 121.93     | 121.93     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099581   | 0.099581   | 0.099581   |   0.0 |  0.08
Output  | 0.000173   | 0.000173   | 0.000173   |   0.0 |  0.00
Modify  | 0.3632     | 0.3632     | 0.3632     |   0.0 |  0.30
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:      134118.0 ave      134118 max      134118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134118
Ave neighs/atom = 67.059000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.731178741083, Press = 13.1485600650077
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13477.173   -13477.173   -13546.591   -13546.591    268.65234    268.65234    31293.197    31293.197    751.96953    751.96953 
    8000   -13478.967   -13478.967   -13548.386   -13548.386    268.65923    268.65923    31299.855    31299.855    15.117174    15.117174 
Loop time of 119.893 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.721 ns/day, 33.304 hours/ns, 8.341 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.39     | 119.39     | 119.39     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097659   | 0.097659   | 0.097659   |   0.0 |  0.08
Output  | 0.00016362 | 0.00016362 | 0.00016362 |   0.0 |  0.00
Modify  | 0.35241    | 0.35241    | 0.35241    |   0.0 |  0.29
Other   |            | 0.05744    |            |       |  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:      134358.0 ave      134358 max      134358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134358
Ave neighs/atom = 67.179000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.476579523922, Press = -1.37976724468941
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13478.967   -13478.967   -13548.386   -13548.386    268.65923    268.65923    31299.855    31299.855    15.117174    15.117174 
    9000   -13476.951   -13476.951    -13547.14    -13547.14    271.63875    271.63875    31308.086    31308.086   -370.17033   -370.17033 
Loop time of 121.194 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.665 hours/ns, 8.251 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.68     | 120.68     | 120.68     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096517   | 0.096517   | 0.096517   |   0.0 |  0.08
Output  | 0.00021455 | 0.00021455 | 0.00021455 |   0.0 |  0.00
Modify  | 0.35844    | 0.35844    | 0.35844    |   0.0 |  0.30
Other   |            | 0.0593     |            |       |  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:      134100.0 ave      134100 max      134100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134100
Ave neighs/atom = 67.050000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.328524224208, Press = -2.69276753672245
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13476.951   -13476.951    -13547.14    -13547.14    271.63875    271.63875    31308.086    31308.086   -370.17033   -370.17033 
   10000   -13481.873   -13481.873   -13549.928   -13549.928    263.38231    263.38231    31301.594    31301.594   -275.31084   -275.31084 
Loop time of 127.949 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.675 ns/day, 35.541 hours/ns, 7.816 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.39     | 127.39     | 127.39     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.102      | 0.102      | 0.102      |   0.0 |  0.08
Output  | 0.00021081 | 0.00021081 | 0.00021081 |   0.0 |  0.00
Modify  | 0.3925     | 0.3925     | 0.3925     |   0.0 |  0.31
Other   |            | 0.06153    |            |       |  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:      134114.0 ave      134114 max      134114 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134114
Ave neighs/atom = 67.057000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.176629229897, Press = -4.38458188490686
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13481.873   -13481.873   -13549.928   -13549.928    263.38231    263.38231    31301.594    31301.594   -275.31084   -275.31084 
   11000   -13477.186   -13477.186   -13548.719   -13548.719    276.84254    276.84254    31307.535    31307.535   -619.41923   -619.41923 
Loop time of 138.673 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.623 ns/day, 38.520 hours/ns, 7.211 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    | 138.06     | 138.06     | 138.06     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10875    | 0.10875    | 0.10875    |   0.0 |  0.08
Output  | 0.00015634 | 0.00015634 | 0.00015634 |   0.0 |  0.00
Modify  | 0.4391     | 0.4391     | 0.4391     |   0.0 |  0.32
Other   |            | 0.06615    |            |       |  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:      133760.0 ave      133760 max      133760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133760
Ave neighs/atom = 66.880000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.021356612059, Press = -2.4675322184086
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13477.186   -13477.186   -13548.719   -13548.719    276.84254    276.84254    31307.535    31307.535   -619.41923   -619.41923 
   12000   -13477.491   -13477.491   -13547.635   -13547.635    271.46645    271.46645    31317.206    31317.206   -1225.1467   -1225.1467 
Loop time of 138.063 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.626 ns/day, 38.351 hours/ns, 7.243 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    | 137.45     | 137.45     | 137.45     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10948    | 0.10948    | 0.10948    |   0.0 |  0.08
Output  | 0.00015657 | 0.00015657 | 0.00015657 |   0.0 |  0.00
Modify  | 0.43976    | 0.43976    | 0.43976    |   0.0 |  0.32
Other   |            | 0.06576    |            |       |  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:      134208.0 ave      134208 max      134208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134208
Ave neighs/atom = 67.104000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.294602975306, Press = -1.62498088868088
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13477.491   -13477.491   -13547.635   -13547.635    271.46645    271.46645    31317.206    31317.206   -1225.1467   -1225.1467 
   13000    -13476.84    -13476.84   -13547.916   -13547.916    275.07353    275.07353    31340.576    31340.576   -3346.0319   -3346.0319 
Loop time of 137.084 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.630 ns/day, 38.079 hours/ns, 7.295 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    | 136.47     | 136.47     | 136.47     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11053    | 0.11053    | 0.11053    |   0.0 |  0.08
Output  | 0.00020806 | 0.00020806 | 0.00020806 |   0.0 |  0.00
Modify  | 0.43921    | 0.43921    | 0.43921    |   0.0 |  0.32
Other   |            | 0.06462    |            |       |  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:      134146.0 ave      134146 max      134146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134146
Ave neighs/atom = 67.073000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.297066224546, Press = -2.45756521143715
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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    -13476.84    -13476.84   -13547.916   -13547.916    275.07353    275.07353    31340.576    31340.576   -3346.0319   -3346.0319 
   14000   -13475.919   -13475.919   -13546.488   -13546.488    273.11058    273.11058    31346.499    31346.499   -3691.3827   -3691.3827 
Loop time of 137.091 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.630 ns/day, 38.081 hours/ns, 7.294 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    | 136.47     | 136.47     | 136.47     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11163    | 0.11163    | 0.11163    |   0.0 |  0.08
Output  | 0.00020652 | 0.00020652 | 0.00020652 |   0.0 |  0.00
Modify  | 0.44252    | 0.44252    | 0.44252    |   0.0 |  0.32
Other   |            | 0.06456    |            |       |  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:      133618.0 ave      133618 max      133618 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133618
Ave neighs/atom = 66.809000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.446342353247, Press = -4.45066214503696
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13475.919   -13475.919   -13546.488   -13546.488    273.11058    273.11058    31346.499    31346.499   -3691.3827   -3691.3827 
   15000   -13476.639   -13476.639    -13548.09    -13548.09     276.5229     276.5229    31318.633    31318.633   -1442.9446   -1442.9446 
Loop time of 131.939 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.655 ns/day, 36.650 hours/ns, 7.579 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.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10602    | 0.10602    | 0.10602    |   0.0 |  0.08
Output  | 0.00041508 | 0.00041508 | 0.00041508 |   0.0 |  0.00
Modify  | 0.411      | 0.411      | 0.411      |   0.0 |  0.31
Other   |            | 0.06298    |            |       |  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:      133682.0 ave      133682 max      133682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133682
Ave neighs/atom = 66.841000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.397454972835, Press = -5.25664270850556
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13476.639   -13476.639    -13548.09    -13548.09     276.5229     276.5229    31318.633    31318.633   -1442.9446   -1442.9446 
   16000   -13478.727   -13478.727   -13547.636   -13547.636    266.68333    266.68333    31312.606    31312.606   -1088.1828   -1088.1828 
Loop time of 138.293 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.625 ns/day, 38.415 hours/ns, 7.231 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    | 137.68     | 137.68     | 137.68     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10806    | 0.10806    | 0.10806    |   0.0 |  0.08
Output  | 0.00015403 | 0.00015403 | 0.00015403 |   0.0 |  0.00
Modify  | 0.43412    | 0.43412    | 0.43412    |   0.0 |  0.31
Other   |            | 0.06569    |            |       |  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:      133988.0 ave      133988 max      133988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133988
Ave neighs/atom = 66.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 = 272.512745233471, Press = -5.39009032634552
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13478.727   -13478.727   -13547.636   -13547.636    266.68333    266.68333    31312.606    31312.606   -1088.1828   -1088.1828 
   17000   -13475.584   -13475.584   -13546.476   -13546.476    274.35758    274.35758    31321.633    31321.633    -1533.155    -1533.155 
Loop time of 133.54 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.647 ns/day, 37.094 hours/ns, 7.488 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    | 132.96     | 132.96     | 132.96     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10522    | 0.10522    | 0.10522    |   0.0 |  0.08
Output  | 0.00020248 | 0.00020248 | 0.00020248 |   0.0 |  0.00
Modify  | 0.41192    | 0.41192    | 0.41192    |   0.0 |  0.31
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:      134132.0 ave      134132 max      134132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134132
Ave neighs/atom = 67.066000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.5030537443, Press = -5.83952587075773
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13475.584   -13475.584   -13546.476   -13546.476    274.35758    274.35758    31321.633    31321.633    -1533.155    -1533.155 
   18000   -13480.436   -13480.436    -13548.67    -13548.67    264.07018    264.07018    31319.603    31319.603   -1598.5376   -1598.5376 
Loop time of 133.041 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.649 ns/day, 36.956 hours/ns, 7.516 timesteps/s
99.9% 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.45     | 132.45     | 132.45     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1075     | 0.1075     | 0.1075     |   0.0 |  0.08
Output  | 0.00019086 | 0.00019086 | 0.00019086 |   0.0 |  0.00
Modify  | 0.42078    | 0.42078    | 0.42078    |   0.0 |  0.32
Other   |            | 0.06474    |            |       |  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:      133990.0 ave      133990 max      133990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133990
Ave neighs/atom = 66.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 = 272.371445260445, Press = -7.609932432105
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13480.436   -13480.436    -13548.67    -13548.67    264.07018    264.07018    31319.603    31319.603   -1598.5376   -1598.5376 
   19000   -13476.285   -13476.285   -13546.951   -13546.951    273.48718    273.48718    31309.374    31309.374   -590.19852   -590.19852 
Loop time of 136.403 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.633 ns/day, 37.890 hours/ns, 7.331 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.8      | 135.8      | 135.8      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10717    | 0.10717    | 0.10717    |   0.0 |  0.08
Output  | 0.00019834 | 0.00019834 | 0.00019834 |   0.0 |  0.00
Modify  | 0.43309    | 0.43309    | 0.43309    |   0.0 |  0.32
Other   |            | 0.06604    |            |       |  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:      133802.0 ave      133802 max      133802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133802
Ave neighs/atom = 66.901000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.284382743324, Press = -8.04320398357891
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13476.285   -13476.285   -13546.951   -13546.951    273.48718    273.48718    31309.374    31309.374   -590.19852   -590.19852 
   20000    -13479.46    -13479.46   -13549.897   -13549.897    272.59552    272.59552    31295.119    31295.119     171.1222     171.1222 
Loop time of 138.863 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.622 ns/day, 38.573 hours/ns, 7.201 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    | 138.25     | 138.25     | 138.25     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10839    | 0.10839    | 0.10839    |   0.0 |  0.08
Output  | 0.0001899  | 0.0001899  | 0.0001899  |   0.0 |  0.00
Modify  | 0.43894    | 0.43894    | 0.43894    |   0.0 |  0.32
Other   |            | 0.06606    |            |       |  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:      134172.0 ave      134172 max      134172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134172
Ave neighs/atom = 67.086000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.222831467206, Press = -4.22444530858233
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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    -13479.46    -13479.46   -13549.897   -13549.897    272.59552    272.59552    31295.119    31295.119     171.1222     171.1222 
   21000   -13475.522   -13475.522   -13547.203   -13547.203    277.41254    277.41254    31291.479    31291.479    1122.9094    1122.9094 
Loop time of 128.837 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.671 ns/day, 35.788 hours/ns, 7.762 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.28     | 128.28     | 128.28     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10204    | 0.10204    | 0.10204    |   0.0 |  0.08
Output  | 0.00015596 | 0.00015596 | 0.00015596 |   0.0 |  0.00
Modify  | 0.39422    | 0.39422    | 0.39422    |   0.0 |  0.31
Other   |            | 0.06219    |            |       |  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:      133998.0 ave      133998 max      133998 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133998
Ave neighs/atom = 66.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 = 272.1827786476, Press = -2.23658590756047
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13475.522   -13475.522   -13547.203   -13547.203    277.41254    277.41254    31291.479    31291.479    1122.9094    1122.9094 
   22000   -13481.484   -13481.484    -13549.33    -13549.33    262.57254    262.57254    31271.512    31271.512    2255.5219    2255.5219 
Loop time of 137.973 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.626 ns/day, 38.326 hours/ns, 7.248 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.36     | 137.36     | 137.36     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10856    | 0.10856    | 0.10856    |   0.0 |  0.08
Output  | 0.0002449  | 0.0002449  | 0.0002449  |   0.0 |  0.00
Modify  | 0.43579    | 0.43579    | 0.43579    |   0.0 |  0.32
Other   |            | 0.06636    |            |       |  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:      134216.0 ave      134216 max      134216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134216
Ave neighs/atom = 67.108000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.176828233833, Press = -1.657810870612
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13481.484   -13481.484    -13549.33    -13549.33    262.57254    262.57254    31271.512    31271.512    2255.5219    2255.5219 
   23000   -13476.491   -13476.491   -13548.817   -13548.817    279.90957    279.90957    31267.582    31267.582    2732.2987    2732.2987 
Loop time of 139.771 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.618 ns/day, 38.825 hours/ns, 7.155 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    | 139.15     | 139.15     | 139.15     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10959    | 0.10959    | 0.10959    |   0.0 |  0.08
Output  | 0.00015627 | 0.00015627 | 0.00015627 |   0.0 |  0.00
Modify  | 0.44356    | 0.44356    | 0.44356    |   0.0 |  0.32
Other   |            | 0.06691    |            |       |  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:      134344.0 ave      134344 max      134344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134344
Ave neighs/atom = 67.172000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.145843137661, Press = -0.0209940697469021
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13476.491   -13476.491   -13548.817   -13548.817    279.90957    279.90957    31267.582    31267.582    2732.2987    2732.2987 
   24000   -13479.784   -13479.784    -13549.43    -13549.43     269.5375     269.5375    31270.673    31270.673     2367.385     2367.385 
Loop time of 140.046 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.617 ns/day, 38.902 hours/ns, 7.141 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    | 139.43     | 139.43     | 139.43     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11014    | 0.11014    | 0.11014    |   0.0 |  0.08
Output  | 0.00021376 | 0.00021376 | 0.00021376 |   0.0 |  0.00
Modify  | 0.44069    | 0.44069    | 0.44069    |   0.0 |  0.31
Other   |            | 0.06667    |            |       |  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:      134482.0 ave      134482 max      134482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134482
Ave neighs/atom = 67.241000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.111992893344, Press = 1.48749044009469
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13479.784   -13479.784    -13549.43    -13549.43     269.5375     269.5375    31270.673    31270.673     2367.385     2367.385 
   25000   -13475.601   -13475.601   -13547.946   -13547.946    279.98035    279.98035    31302.823    31302.823    -35.16824    -35.16824 
Loop time of 140.143 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.617 ns/day, 38.929 hours/ns, 7.136 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    | 139.53     | 139.53     | 139.53     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10918    | 0.10918    | 0.10918    |   0.0 |  0.08
Output  | 0.00015468 | 0.00015468 | 0.00015468 |   0.0 |  0.00
Modify  | 0.44104    | 0.44104    | 0.44104    |   0.0 |  0.31
Other   |            | 0.06676    |            |       |  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:      134298.0 ave      134298 max      134298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134298
Ave neighs/atom = 67.149000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.079450387768, Press = -0.0430438580043484
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13475.601   -13475.601   -13547.946   -13547.946    279.98035    279.98035    31302.823    31302.823    -35.16824    -35.16824 
   26000   -13478.725   -13478.725   -13547.998   -13547.998    268.09201    268.09201    31305.464    31305.464   -520.84904   -520.84904 
Loop time of 126.858 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.681 ns/day, 35.238 hours/ns, 7.883 timesteps/s
99.9% 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.31     | 126.31     | 126.31     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10061    | 0.10061    | 0.10061    |   0.0 |  0.08
Output  | 0.00015466 | 0.00015466 | 0.00015466 |   0.0 |  0.00
Modify  | 0.38588    | 0.38588    | 0.38588    |   0.0 |  0.30
Other   |            | 0.06217    |            |       |  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:      134162.0 ave      134162 max      134162 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134162
Ave neighs/atom = 67.081000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.066892690082, Press = -1.10754583884602
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13478.725   -13478.725   -13547.998   -13547.998    268.09201    268.09201    31305.464    31305.464   -520.84904   -520.84904 
   27000   -13476.971   -13476.971   -13548.083   -13548.083    275.21114    275.21114    31305.094    31305.094   -396.51588   -396.51588 
Loop time of 121.948 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.708 ns/day, 33.874 hours/ns, 8.200 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.43     | 121.43     | 121.43     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097125   | 0.097125   | 0.097125   |   0.0 |  0.08
Output  | 0.00015888 | 0.00015888 | 0.00015888 |   0.0 |  0.00
Modify  | 0.36255    | 0.36255    | 0.36255    |   0.0 |  0.30
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:      134094.0 ave      134094 max      134094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134094
Ave neighs/atom = 67.047000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.119590933927, Press = -1.72433361265343
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13476.971   -13476.971   -13548.083   -13548.083    275.21114    275.21114    31305.094    31305.094   -396.51588   -396.51588 
   28000   -13477.365   -13477.365   -13547.925   -13547.925    273.07498    273.07498    31300.971    31300.971    2.3197064    2.3197064 
Loop time of 132.009 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.654 ns/day, 36.669 hours/ns, 7.575 timesteps/s
99.9% 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.43     | 131.43     | 131.43     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10386    | 0.10386    | 0.10386    |   0.0 |  0.08
Output  | 0.0002551  | 0.0002551  | 0.0002551  |   0.0 |  0.00
Modify  | 0.41092    | 0.41092    | 0.41092    |   0.0 |  0.31
Other   |            | 0.06381    |            |       |  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:      134020.0 ave      134020 max      134020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134020
Ave neighs/atom = 67.010000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.129877598004, Press = -1.55961536826475
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13477.365   -13477.365   -13547.925   -13547.925    273.07498    273.07498    31300.971    31300.971    2.3197064    2.3197064 
   29000    -13476.94    -13476.94   -13547.695   -13547.695    273.82775    273.82775    31296.684    31296.684    332.00118    332.00118 
Loop time of 138.039 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.626 ns/day, 38.344 hours/ns, 7.244 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.43     | 137.43     | 137.43     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10828    | 0.10828    | 0.10828    |   0.0 |  0.08
Output  | 0.00015697 | 0.00015697 | 0.00015697 |   0.0 |  0.00
Modify  | 0.43456    | 0.43456    | 0.43456    |   0.0 |  0.31
Other   |            | 0.06671    |            |       |  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:      133966.0 ave      133966 max      133966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133966
Ave neighs/atom = 66.983000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.217189950482, Press = -1.2607290465817
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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    -13476.94    -13476.94   -13547.695   -13547.695    273.82775    273.82775    31296.684    31296.684    332.00118    332.00118 
   30000   -13478.659   -13478.659   -13547.149   -13547.149    265.06301    265.06301    31298.069    31298.069     311.3806     311.3806 
Loop time of 131.967 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.655 ns/day, 36.658 hours/ns, 7.578 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.39     | 131.39     | 131.39     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10392    | 0.10392    | 0.10392    |   0.0 |  0.08
Output  | 0.00015501 | 0.00015501 | 0.00015501 |   0.0 |  0.00
Modify  | 0.40946    | 0.40946    | 0.40946    |   0.0 |  0.31
Other   |            | 0.06435    |            |       |  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:      134116.0 ave      134116 max      134116 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134116
Ave neighs/atom = 67.058000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.173173961816, Press = -0.78059668520574
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13478.659   -13478.659   -13547.149   -13547.149    265.06301    265.06301    31298.069    31298.069     311.3806     311.3806 
   31000   -13477.029   -13477.029   -13546.997   -13546.997     270.7808     270.7808    31313.442    31313.442   -973.81913   -973.81913 
Loop time of 135.107 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.639 ns/day, 37.530 hours/ns, 7.402 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    | 134.51     | 134.51     | 134.51     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10689    | 0.10689    | 0.10689    |   0.0 |  0.08
Output  | 0.00015661 | 0.00015661 | 0.00015661 |   0.0 |  0.00
Modify  | 0.42131    | 0.42131    | 0.42131    |   0.0 |  0.31
Other   |            | 0.06474    |            |       |  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:      134124.0 ave      134124 max      134124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134124
Ave neighs/atom = 67.062000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.181019979866, Press = -0.371783335764496
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13477.029   -13477.029   -13546.997   -13546.997     270.7808     270.7808    31313.442    31313.442   -973.81913   -973.81913 
   32000   -13478.297   -13478.297   -13547.576   -13547.576    268.11566    268.11566    31333.304    31333.304   -2740.7639   -2740.7639 
Loop time of 138.654 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.623 ns/day, 38.515 hours/ns, 7.212 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    | 138.04     | 138.04     | 138.04     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10887    | 0.10887    | 0.10887    |   0.0 |  0.08
Output  | 0.0001883  | 0.0001883  | 0.0001883  |   0.0 |  0.00
Modify  | 0.44087    | 0.44087    | 0.44087    |   0.0 |  0.32
Other   |            | 0.06679    |            |       |  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:      133934.0 ave      133934 max      133934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133934
Ave neighs/atom = 66.967000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.131712848107, Press = -0.429692565786472
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13478.297   -13478.297   -13547.576   -13547.576    268.11566    268.11566    31333.304    31333.304   -2740.7639   -2740.7639 
   33000   -13478.311   -13478.311   -13546.335   -13546.335    263.25649    263.25649    31333.749    31333.749    -2738.613    -2738.613 
Loop time of 138.677 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.623 ns/day, 38.521 hours/ns, 7.211 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.06     | 138.06     | 138.06     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10912    | 0.10912    | 0.10912    |   0.0 |  0.08
Output  | 0.00024334 | 0.00024334 | 0.00024334 |   0.0 |  0.00
Modify  | 0.43897    | 0.43897    | 0.43897    |   0.0 |  0.32
Other   |            | 0.06693    |            |       |  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:      133638.0 ave      133638 max      133638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133638
Ave neighs/atom = 66.819000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.229875882157, Press = -0.981995124415191
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13478.311   -13478.311   -13546.335   -13546.335    263.25649    263.25649    31333.749    31333.749    -2738.613    -2738.613 
   34000   -13475.605   -13475.605    -13545.31    -13545.31    269.76513    269.76513    31320.503    31320.503   -1448.2628   -1448.2628 
Loop time of 119.626 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.722 ns/day, 33.229 hours/ns, 8.359 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.12     | 119.12     | 119.12     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094144   | 0.094144   | 0.094144   |   0.0 |  0.08
Output  | 0.00015413 | 0.00015413 | 0.00015413 |   0.0 |  0.00
Modify  | 0.35218    | 0.35218    | 0.35218    |   0.0 |  0.29
Other   |            | 0.05986    |            |       |  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:      133964.0 ave      133964 max      133964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133964
Ave neighs/atom = 66.982000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.305742998602, Press = -1.47358715264434
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13475.605   -13475.605    -13545.31    -13545.31    269.76513    269.76513    31320.503    31320.503   -1448.2628   -1448.2628 
   35000   -13478.797   -13478.797    -13546.81    -13546.81    263.21862    263.21862    31301.095    31301.095    67.142789    67.142789 
Loop time of 119.807 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.721 ns/day, 33.280 hours/ns, 8.347 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.3      | 119.3      | 119.3      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094397   | 0.094397   | 0.094397   |   0.0 |  0.08
Output  | 0.00015546 | 0.00015546 | 0.00015546 |   0.0 |  0.00
Modify  | 0.35391    | 0.35391    | 0.35391    |   0.0 |  0.30
Other   |            | 0.06055    |            |       |  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:      134206.0 ave      134206 max      134206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134206
Ave neighs/atom = 67.103000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.379168278099, Press = -1.55478527467352
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13478.797   -13478.797    -13546.81    -13546.81    263.21862    263.21862    31301.095    31301.095    67.142789    67.142789 
   36000    -13472.76    -13472.76   -13547.119   -13547.119    287.77653    287.77653    31298.343    31298.343    515.30349    515.30349 
Loop time of 139.356 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.620 ns/day, 38.710 hours/ns, 7.176 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    | 138.74     | 138.74     | 138.74     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10988    | 0.10988    | 0.10988    |   0.0 |  0.08
Output  | 0.00015447 | 0.00015447 | 0.00015447 |   0.0 |  0.00
Modify  | 0.4408     | 0.4408     | 0.4408     |   0.0 |  0.32
Other   |            | 0.06601    |            |       |  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:      134366.0 ave      134366 max      134366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134366
Ave neighs/atom = 67.183000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.468418328912, Press = -1.63296831456958
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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    -13472.76    -13472.76   -13547.119   -13547.119    287.77653    287.77653    31298.343    31298.343    515.30349    515.30349 
   37000   -13478.761   -13478.761   -13549.698   -13549.698     274.5353     274.5353    31277.842    31277.842    1808.2842    1808.2842 
Loop time of 139.546 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.619 ns/day, 38.763 hours/ns, 7.166 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.93     | 138.93     | 138.93     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10948    | 0.10948    | 0.10948    |   0.0 |  0.08
Output  | 0.00015666 | 0.00015666 | 0.00015666 |   0.0 |  0.00
Modify  | 0.44082    | 0.44082    | 0.44082    |   0.0 |  0.32
Other   |            | 0.06612    |            |       |  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:      134148.0 ave      134148 max      134148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134148
Ave neighs/atom = 67.074000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.504325660543, Press = -1.6910207659408
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13478.761   -13478.761   -13549.698   -13549.698     274.5353     274.5353    31277.842    31277.842    1808.2842    1808.2842 
   38000   -13477.322   -13477.322   -13547.108   -13547.108    270.07936    270.07936    31253.561    31253.561    4220.9449    4220.9449 
Loop time of 139.044 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.621 ns/day, 38.623 hours/ns, 7.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    | 138.43     | 138.43     | 138.43     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10906    | 0.10906    | 0.10906    |   0.0 |  0.08
Output  | 0.00026119 | 0.00026119 | 0.00026119 |   0.0 |  0.00
Modify  | 0.43998    | 0.43998    | 0.43998    |   0.0 |  0.32
Other   |            | 0.06659    |            |       |  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:      134100.0 ave      134100 max      134100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134100
Ave neighs/atom = 67.050000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.521955979117, Press = -0.840406864574063
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13477.322   -13477.322   -13547.108   -13547.108    270.07936    270.07936    31253.561    31253.561    4220.9449    4220.9449 
   39000   -13479.057   -13479.057   -13549.112   -13549.112    271.12198    271.12198     31264.59     31264.59    2897.0358    2897.0358 
Loop time of 139.714 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.618 ns/day, 38.809 hours/ns, 7.157 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.1      | 139.1      | 139.1      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10915    | 0.10915    | 0.10915    |   0.0 |  0.08
Output  | 0.00019914 | 0.00019914 | 0.00019914 |   0.0 |  0.00
Modify  | 0.43988    | 0.43988    | 0.43988    |   0.0 |  0.31
Other   |            | 0.06653    |            |       |  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:      134762.0 ave      134762 max      134762 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134762
Ave neighs/atom = 67.381000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.460962403444, Press = -0.209902659553451
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13479.057   -13479.057   -13549.112   -13549.112    271.12198    271.12198     31264.59     31264.59    2897.0358    2897.0358 
   40000   -13477.506   -13477.506   -13548.653   -13548.653    275.34613    275.34613    31278.248    31278.248    1744.9041    1744.9041 
Loop time of 124.608 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.693 ns/day, 34.613 hours/ns, 8.025 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    | 124.08     | 124.08     | 124.08     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099081   | 0.099081   | 0.099081   |   0.0 |  0.08
Output  | 0.00017075 | 0.00017075 | 0.00017075 |   0.0 |  0.00
Modify  | 0.37362    | 0.37362    | 0.37362    |   0.0 |  0.30
Other   |            | 0.05975    |            |       |  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:      134678.0 ave      134678 max      134678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134678
Ave neighs/atom = 67.339000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.456677121865, Press = 0.170980743835279
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13477.506   -13477.506   -13548.653   -13548.653    275.34613    275.34613    31278.248    31278.248    1744.9041    1744.9041 
   41000   -13474.299   -13474.299   -13544.584   -13544.584    272.01251    272.01251    31297.332    31297.332    703.28532    703.28532 
Loop time of 119.285 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.135 hours/ns, 8.383 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.78     | 118.78     | 118.78     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094347   | 0.094347   | 0.094347   |   0.0 |  0.08
Output  | 0.00046192 | 0.00046192 | 0.00046192 |   0.0 |  0.00
Modify  | 0.34928    | 0.34928    | 0.34928    |   0.0 |  0.29
Other   |            | 0.05862    |            |       |  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:      134294.0 ave      134294 max      134294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134294
Ave neighs/atom = 67.147000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.466199464898, Press = 0.243278145057733
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13474.299   -13474.299   -13544.584   -13544.584    272.01251    272.01251    31297.332    31297.332    703.28532    703.28532 
   42000   -13477.993   -13477.993   -13548.067   -13548.067    271.19307    271.19307    31307.032    31307.032   -692.75113   -692.75113 
Loop time of 119.342 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.151 hours/ns, 8.379 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.84     | 118.84     | 118.84     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094158   | 0.094158   | 0.094158   |   0.0 |  0.08
Output  | 0.0001549  | 0.0001549  | 0.0001549  |   0.0 |  0.00
Modify  | 0.35037    | 0.35037    | 0.35037    |   0.0 |  0.29
Other   |            | 0.05933    |            |       |  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:      134508.0 ave      134508 max      134508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134508
Ave neighs/atom = 67.254000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.507715037923, Press = -0.114530594096768
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13477.993   -13477.993   -13548.067   -13548.067    271.19307    271.19307    31307.032    31307.032   -692.75113   -692.75113 
   43000   -13473.818   -13473.818   -13546.724   -13546.724    282.15353    282.15353    31313.766    31313.766   -862.91652   -862.91652 
Loop time of 119.29 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.136 hours/ns, 8.383 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.79     | 118.79     | 118.79     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094366   | 0.094366   | 0.094366   |   0.0 |  0.08
Output  | 0.00015593 | 0.00015593 | 0.00015593 |   0.0 |  0.00
Modify  | 0.34972    | 0.34972    | 0.34972    |   0.0 |  0.29
Other   |            | 0.05953    |            |       |  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:      134208.0 ave      134208 max      134208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134208
Ave neighs/atom = 67.104000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.588551716668, Press = -0.523624603293642
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13473.818   -13473.818   -13546.724   -13546.724    282.15353    282.15353    31313.766    31313.766   -862.91652   -862.91652 
   44000   -13475.873   -13475.873   -13546.775   -13546.775    274.40034    274.40034     31315.52     31315.52   -909.60959   -909.60959 
Loop time of 128.926 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.670 ns/day, 35.813 hours/ns, 7.756 timesteps/s
99.9% 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.37     | 128.37     | 128.37     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.102      | 0.102      | 0.102      |   0.0 |  0.08
Output  | 0.00015738 | 0.00015738 | 0.00015738 |   0.0 |  0.00
Modify  | 0.39386    | 0.39386    | 0.39386    |   0.0 |  0.31
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:      134212.0 ave      134212 max      134212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134212
Ave neighs/atom = 67.106000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.628267169564, Press = -0.928624742862438
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13475.873   -13475.873   -13546.775   -13546.775    274.40034    274.40034     31315.52     31315.52   -909.60959   -909.60959 
   45000   -13479.072   -13479.072    -13548.05    -13548.05    266.95071    266.95071    31304.967    31304.967   -466.32747   -466.32747 
Loop time of 132.474 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.652 ns/day, 36.798 hours/ns, 7.549 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.9      | 131.9      | 131.9      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10507    | 0.10507    | 0.10507    |   0.0 |  0.08
Output  | 0.00015546 | 0.00015546 | 0.00015546 |   0.0 |  0.00
Modify  | 0.40938    | 0.40938    | 0.40938    |   0.0 |  0.31
Other   |            | 0.06322    |            |       |  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:      133994.0 ave      133994 max      133994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133994
Ave neighs/atom = 66.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 = 272.633737586578, Press = -1.23149876530961
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13479.072   -13479.072    -13548.05    -13548.05    266.95071    266.95071    31304.967    31304.967   -466.32747   -466.32747 
   46000   -13476.192   -13476.192   -13548.091   -13548.091    278.25596    278.25596    31300.278    31300.278   -30.598345   -30.598345 
Loop time of 119.331 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.148 hours/ns, 8.380 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.83     | 118.83     | 118.83     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095486   | 0.095486   | 0.095486   |   0.0 |  0.08
Output  | 0.00015717 | 0.00015717 | 0.00015717 |   0.0 |  0.00
Modify  | 0.35177    | 0.35177    | 0.35177    |   0.0 |  0.29
Other   |            | 0.05786    |            |       |  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:      134132.0 ave      134132 max      134132 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134132
Ave neighs/atom = 67.066000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.573541340907, Press = -1.18441252166271
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13476.192   -13476.192   -13548.091   -13548.091    278.25596    278.25596    31300.278    31300.278   -30.598345   -30.598345 
   47000   -13477.847   -13477.847   -13548.056   -13548.056    271.71635    271.71635    31299.867    31299.867     32.41308     32.41308 
Loop time of 126.402 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.684 ns/day, 35.112 hours/ns, 7.911 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.86     | 125.86     | 125.86     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10095    | 0.10095    | 0.10095    |   0.0 |  0.08
Output  | 0.00015604 | 0.00015604 | 0.00015604 |   0.0 |  0.00
Modify  | 0.38328    | 0.38328    | 0.38328    |   0.0 |  0.30
Other   |            | 0.06056    |            |       |  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:      134088.0 ave      134088 max      134088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134088
Ave neighs/atom = 67.044000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.586405896983, Press = -0.879979988614768
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13477.847   -13477.847   -13548.056   -13548.056    271.71635    271.71635    31299.867    31299.867     32.41308     32.41308 
   48000   -13475.843   -13475.843   -13547.215   -13547.215    276.21869    276.21869    31303.596    31303.596   -131.73593   -131.73593 
Loop time of 125.441 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.689 ns/day, 34.845 hours/ns, 7.972 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    | 124.9      | 124.9      | 124.9      |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099414   | 0.099414   | 0.099414   |   0.0 |  0.08
Output  | 0.00015357 | 0.00015357 | 0.00015357 |   0.0 |  0.00
Modify  | 0.38085    | 0.38085    | 0.38085    |   0.0 |  0.30
Other   |            | 0.06048    |            |       |  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:      134422.0 ave      134422 max      134422 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134422
Ave neighs/atom = 67.211000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.638191018968, Press = -0.796877962947943
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13475.843   -13475.843   -13547.215   -13547.215    276.21869    276.21869    31303.596    31303.596   -131.73593   -131.73593 
   49000   -13477.076   -13477.076   -13546.094   -13546.094    267.10765    267.10765    31302.213    31302.213    170.69725    170.69725 
Loop time of 123.297 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.701 ns/day, 34.249 hours/ns, 8.110 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.77     | 122.77     | 122.77     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098888   | 0.098888   | 0.098888   |   0.0 |  0.08
Output  | 0.00015641 | 0.00015641 | 0.00015641 |   0.0 |  0.00
Modify  | 0.37183    | 0.37183    | 0.37183    |   0.0 |  0.30
Other   |            | 0.0604     |            |       |  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:      134166.0 ave      134166 max      134166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134166
Ave neighs/atom = 67.083000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.662805687891, Press = -0.616100746814388
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13477.076   -13477.076   -13546.094   -13546.094    267.10765    267.10765    31302.213    31302.213    170.69725    170.69725 
   50000   -13474.529   -13474.529   -13545.371   -13545.371    274.16642    274.16642    31310.367    31310.367   -278.40231   -278.40231 
Loop time of 118.836 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.727 ns/day, 33.010 hours/ns, 8.415 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.33     | 118.33     | 118.33     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094209   | 0.094209   | 0.094209   |   0.0 |  0.08
Output  | 0.00015516 | 0.00015516 | 0.00015516 |   0.0 |  0.00
Modify  | 0.3492     | 0.3492     | 0.3492     |   0.0 |  0.29
Other   |            | 0.05926    |            |       |  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:      134142.0 ave      134142 max      134142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134142
Ave neighs/atom = 67.071000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.747546037536, Press = -0.774716400292522
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13474.529   -13474.529   -13545.371   -13545.371    274.16642    274.16642    31310.367    31310.367   -278.40231   -278.40231 
   51000   -13477.021   -13477.021   -13546.263   -13546.263    267.97257    267.97257    31319.498    31319.498   -1204.2995   -1204.2995 
Loop time of 119.036 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.066 hours/ns, 8.401 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.53     | 118.53     | 118.53     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094836   | 0.094836   | 0.094836   |   0.0 |  0.08
Output  | 0.00015568 | 0.00015568 | 0.00015568 |   0.0 |  0.00
Modify  | 0.35116    | 0.35116    | 0.35116    |   0.0 |  0.29
Other   |            | 0.05913    |            |       |  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:      134070.0 ave      134070 max      134070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134070
Ave neighs/atom = 67.035000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.766704786574, Press = -0.652070621939601
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13477.021   -13477.021   -13546.263   -13546.263    267.97257    267.97257    31319.498    31319.498   -1204.2995   -1204.2995 
   52000   -13476.011   -13476.011   -13548.006   -13548.006    278.62785    278.62785    31329.931    31329.931   -2390.1639   -2390.1639 
Loop time of 118.747 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.728 ns/day, 32.985 hours/ns, 8.421 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.24     | 118.24     | 118.24     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093706   | 0.093706   | 0.093706   |   0.0 |  0.08
Output  | 0.00015499 | 0.00015499 | 0.00015499 |   0.0 |  0.00
Modify  | 0.34924    | 0.34924    | 0.34924    |   0.0 |  0.29
Other   |            | 0.05922    |            |       |  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:      134042.0 ave      134042 max      134042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134042
Ave neighs/atom = 67.021000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.772533296532, Press = -0.732402872430455
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13476.011   -13476.011   -13548.006   -13548.006    278.62785    278.62785    31329.931    31329.931   -2390.1639   -2390.1639 
   53000   -13477.552   -13477.552   -13549.116   -13549.116    276.95887    276.95887    31343.223    31343.223   -3673.1452   -3673.1452 
Loop time of 119.069 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.075 hours/ns, 8.398 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.56     | 118.56     | 118.56     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094178   | 0.094178   | 0.094178   |   0.0 |  0.08
Output  | 0.00015416 | 0.00015416 | 0.00015416 |   0.0 |  0.00
Modify  | 0.35131    | 0.35131    | 0.35131    |   0.0 |  0.30
Other   |            | 0.05932    |            |       |  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:      133786.0 ave      133786 max      133786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133786
Ave neighs/atom = 66.893000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.773298568719, Press = -0.883095306245768
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13477.552   -13477.552   -13549.116   -13549.116    276.95887    276.95887    31343.223    31343.223   -3673.1452   -3673.1452 
   54000   -13473.901   -13473.901   -13546.428   -13546.428    280.68908    280.68908    31344.263    31344.263   -3328.8591   -3328.8591 
Loop time of 119.583 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.723 ns/day, 33.218 hours/ns, 8.362 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.07     | 119.07     | 119.07     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095434   | 0.095434   | 0.095434   |   0.0 |  0.08
Output  | 0.0002162  | 0.0002162  | 0.0002162  |   0.0 |  0.00
Modify  | 0.35402    | 0.35402    | 0.35402    |   0.0 |  0.30
Other   |            | 0.05915    |            |       |  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:      133556.0 ave      133556 max      133556 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133556
Ave neighs/atom = 66.778000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.783590198414, Press = -1.49382575055253
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13473.901   -13473.901   -13546.428   -13546.428    280.68908    280.68908    31344.263    31344.263   -3328.8591   -3328.8591 
   55000   -13478.077   -13478.077   -13549.535   -13549.535    276.55096    276.55096    31313.513    31313.513   -1056.2849   -1056.2849 
Loop time of 123.414 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.282 hours/ns, 8.103 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.89     | 122.89     | 122.89     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097766   | 0.097766   | 0.097766   |   0.0 |  0.08
Output  | 0.00015527 | 0.00015527 | 0.00015527 |   0.0 |  0.00
Modify  | 0.36804    | 0.36804    | 0.36804    |   0.0 |  0.30
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:      133640.0 ave      133640 max      133640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133640
Ave neighs/atom = 66.820000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.824522158664, Press = -1.51021396413688
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13478.077   -13478.077   -13549.535   -13549.535    276.55096    276.55096    31313.513    31313.513   -1056.2849   -1056.2849 
   56000   -13476.178   -13476.178   -13546.058   -13546.058    270.44475    270.44475    31303.163    31303.163    156.50441    156.50441 
Loop time of 118.966 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.046 hours/ns, 8.406 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.46     | 118.46     | 118.46     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094348   | 0.094348   | 0.094348   |   0.0 |  0.08
Output  | 0.00015491 | 0.00015491 | 0.00015491 |   0.0 |  0.00
Modify  | 0.34788    | 0.34788    | 0.34788    |   0.0 |  0.29
Other   |            | 0.05972    |            |       |  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:      133664.0 ave      133664 max      133664 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133664
Ave neighs/atom = 66.832000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.87153203896, Press = -1.46406556380726
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13476.178   -13476.178   -13546.058   -13546.058    270.44475    270.44475    31303.163    31303.163    156.50441    156.50441 
   57000   -13475.713   -13475.713   -13546.375   -13546.375    273.46735    273.46735    31298.651    31298.651    467.75638    467.75638 
Loop time of 119.263 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.724 ns/day, 33.129 hours/ns, 8.385 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.76     | 118.76     | 118.76     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094144   | 0.094144   | 0.094144   |   0.0 |  0.08
Output  | 0.00015487 | 0.00015487 | 0.00015487 |   0.0 |  0.00
Modify  | 0.35021    | 0.35021    | 0.35021    |   0.0 |  0.29
Other   |            | 0.05915    |            |       |  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:      134212.0 ave      134212 max      134212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134212
Ave neighs/atom = 67.106000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.882900388129, Press = -1.37571672267238
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13475.713   -13475.713   -13546.375   -13546.375    273.46735    273.46735    31298.651    31298.651    467.75638    467.75638 
   58000   -13477.476   -13477.476   -13546.399   -13546.399    266.74019    266.74019    31282.261    31282.261     1691.546     1691.546 
Loop time of 126.973 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.680 ns/day, 35.270 hours/ns, 7.876 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    | 126.42     | 126.42     | 126.42     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10062    | 0.10062    | 0.10062    |   0.0 |  0.08
Output  | 0.00021429 | 0.00021429 | 0.00021429 |   0.0 |  0.00
Modify  | 0.38609    | 0.38609    | 0.38609    |   0.0 |  0.30
Other   |            | 0.06187    |            |       |  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:      134180.0 ave      134180 max      134180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134180
Ave neighs/atom = 67.090000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.93717922568, Press = -1.19979847022567
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13477.476   -13477.476   -13546.399   -13546.399    266.74019    266.74019    31282.261    31282.261     1691.546     1691.546 
   59000   -13476.362   -13476.362   -13547.883   -13547.883    276.79291    276.79291    31265.126    31265.126    3073.0679    3073.0679 
Loop time of 137.778 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.627 ns/day, 38.272 hours/ns, 7.258 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.17     | 137.17     | 137.17     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10745    | 0.10745    | 0.10745    |   0.0 |  0.08
Output  | 0.00018843 | 0.00018843 | 0.00018843 |   0.0 |  0.00
Modify  | 0.43218    | 0.43218    | 0.43218    |   0.0 |  0.31
Other   |            | 0.0656     |            |       |  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:      134464.0 ave      134464 max      134464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134464
Ave neighs/atom = 67.232000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.937532171839, Press = -0.95044920422975
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13476.362   -13476.362   -13547.883   -13547.883    276.79291    276.79291    31265.126    31265.126    3073.0679    3073.0679 
   60000   -13480.839   -13480.839   -13549.663   -13549.663    266.35589    266.35589    31259.103    31259.103     3247.567     3247.567 
Loop time of 133.048 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.649 ns/day, 36.958 hours/ns, 7.516 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    | 132.46     | 132.46     | 132.46     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10424    | 0.10424    | 0.10424    |   0.0 |  0.08
Output  | 0.00029134 | 0.00029134 | 0.00029134 |   0.0 |  0.00
Modify  | 0.41449    | 0.41449    | 0.41449    |   0.0 |  0.31
Other   |            | 0.06505    |            |       |  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:      134478.0 ave      134478 max      134478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134478
Ave neighs/atom = 67.239000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.908123662004, Press = -0.485320276844908
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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   -13480.839   -13480.839   -13549.663   -13549.663    266.35589    266.35589    31259.103    31259.103     3247.567     3247.567 
   61000   -13475.443   -13475.443   -13548.095   -13548.095    281.16785    281.16785    31277.084    31277.084    1908.2101    1908.2101 
Loop time of 139.7 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.618 ns/day, 38.806 hours/ns, 7.158 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.08     | 139.08     | 139.08     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10987    | 0.10987    | 0.10987    |   0.0 |  0.08
Output  | 0.00021846 | 0.00021846 | 0.00021846 |   0.0 |  0.00
Modify  | 0.44228    | 0.44228    | 0.44228    |   0.0 |  0.32
Other   |            | 0.06854    |            |       |  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:      134328.0 ave      134328 max      134328 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134328
Ave neighs/atom = 67.164000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.898139330148, Press = -0.332207916238219
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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 
   61000   -13475.443   -13475.443   -13548.095   -13548.095    281.16785    281.16785    31277.084    31277.084    1908.2101    1908.2101 
   62000   -13479.759   -13479.759   -13549.035   -13549.035    268.10615    268.10615    31287.014    31287.014    869.57829    869.57829 
Loop time of 139.406 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.620 ns/day, 38.724 hours/ns, 7.173 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    | 138.79     | 138.79     | 138.79     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10884    | 0.10884    | 0.10884    |   0.0 |  0.08
Output  | 0.00021231 | 0.00021231 | 0.00021231 |   0.0 |  0.00
Modify  | 0.4392     | 0.4392     | 0.4392     |   0.0 |  0.32
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:      134576.0 ave      134576 max      134576 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134576
Ave neighs/atom = 67.288000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.857214639858, Press = -0.340963198954273
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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 
   62000   -13479.759   -13479.759   -13549.035   -13549.035    268.10615    268.10615    31287.014    31287.014    869.57829    869.57829 
   63000   -13475.924   -13475.924   -13547.067   -13547.067    275.33279    275.33279    31306.676    31306.676   -334.83799   -334.83799 
Loop time of 139.129 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.621 ns/day, 38.647 hours/ns, 7.188 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    | 138.51     | 138.51     | 138.51     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10819    | 0.10819    | 0.10819    |   0.0 |  0.08
Output  | 0.00015562 | 0.00015562 | 0.00015562 |   0.0 |  0.00
Modify  | 0.44       | 0.44       | 0.44       |   0.0 |  0.32
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:      134268.0 ave      134268 max      134268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134268
Ave neighs/atom = 67.134000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.826680130895, Press = -0.420274848140574
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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 
   63000   -13475.924   -13475.924   -13547.067   -13547.067    275.33279    275.33279    31306.676    31306.676   -334.83799   -334.83799 
   64000   -13479.524   -13479.524   -13549.313   -13549.313     270.0933     270.0933    31301.814    31301.814    -347.3275    -347.3275 
Loop time of 138.817 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.622 ns/day, 38.560 hours/ns, 7.204 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.2      | 138.2      | 138.2      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10743    | 0.10743    | 0.10743    |   0.0 |  0.08
Output  | 0.00015772 | 0.00015772 | 0.00015772 |   0.0 |  0.00
Modify  | 0.43907    | 0.43907    | 0.43907    |   0.0 |  0.32
Other   |            | 0.06644    |            |       |  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:      134266.0 ave      134266 max      134266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134266
Ave neighs/atom = 67.133000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.808269933703, Press = -0.672207142740465
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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 
   64000   -13479.524   -13479.524   -13549.313   -13549.313     270.0933     270.0933    31301.814    31301.814    -347.3275    -347.3275 
   65000     -13475.2     -13475.2   -13545.189   -13545.189    270.86145    270.86145    31302.505    31302.505     125.5756     125.5756 
Loop time of 138.813 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.622 ns/day, 38.559 hours/ns, 7.204 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.2      | 138.2      | 138.2      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10802    | 0.10802    | 0.10802    |   0.0 |  0.08
Output  | 0.00019643 | 0.00019643 | 0.00019643 |   0.0 |  0.00
Modify  | 0.43691    | 0.43691    | 0.43691    |   0.0 |  0.31
Other   |            | 0.06638    |            |       |  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:      134222.0 ave      134222 max      134222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134222
Ave neighs/atom = 67.111000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.819684841292, Press = -0.682926945278947
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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 
   65000     -13475.2     -13475.2   -13545.189   -13545.189    270.86145    270.86145    31302.505    31302.505     125.5756     125.5756 
   66000   -13478.782   -13478.782   -13548.296   -13548.296    269.02599    269.02599    31296.281    31296.281    271.76977    271.76977 
Loop time of 138.895 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.622 ns/day, 38.582 hours/ns, 7.200 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    | 138.28     | 138.28     | 138.28     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10896    | 0.10896    | 0.10896    |   0.0 |  0.08
Output  | 0.00021546 | 0.00021546 | 0.00021546 |   0.0 |  0.00
Modify  | 0.43832    | 0.43832    | 0.43832    |   0.0 |  0.32
Other   |            | 0.06597    |            |       |  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:      134270.0 ave      134270 max      134270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134270
Ave neighs/atom = 67.135000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.8350333591, Press = -0.696144490018724
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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 
   66000   -13478.782   -13478.782   -13548.296   -13548.296    269.02599    269.02599    31296.281    31296.281    271.76977    271.76977 
   67000   -13476.609   -13476.609   -13547.635   -13547.635    274.88062    274.88062    31300.012    31300.012    102.60632    102.60632 
Loop time of 139.116 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.621 ns/day, 38.643 hours/ns, 7.188 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    | 138.5      | 138.5      | 138.5      |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10823    | 0.10823    | 0.10823    |   0.0 |  0.08
Output  | 0.00049617 | 0.00049617 | 0.00049617 |   0.0 |  0.00
Modify  | 0.4366     | 0.4366     | 0.4366     |   0.0 |  0.31
Other   |            | 0.06594    |            |       |  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:      134136.0 ave      134136 max      134136 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134136
Ave neighs/atom = 67.068000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.83316740154, Press = -0.644464111321826
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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 
   67000   -13476.609   -13476.609   -13547.635   -13547.635    274.88062    274.88062    31300.012    31300.012    102.60632    102.60632 
   68000   -13476.553   -13476.553   -13548.233   -13548.233    277.41091    277.41091    31309.269    31309.269   -607.80747   -607.80747 
Loop time of 139.083 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.621 ns/day, 38.634 hours/ns, 7.190 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    | 138.47     | 138.47     | 138.47     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10874    | 0.10874    | 0.10874    |   0.0 |  0.08
Output  | 0.00020918 | 0.00020918 | 0.00020918 |   0.0 |  0.00
Modify  | 0.43991    | 0.43991    | 0.43991    |   0.0 |  0.32
Other   |            | 0.06648    |            |       |  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:      133954.0 ave      133954 max      133954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133954
Ave neighs/atom = 66.977000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.850931767116, Press = -0.861758698084518
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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 
   68000   -13476.553   -13476.553   -13548.233   -13548.233    277.41091    277.41091    31309.269    31309.269   -607.80747   -607.80747 
   69000    -13473.34    -13473.34   -13544.987   -13544.987    277.28416    277.28416    31314.212    31314.212   -627.13215   -627.13215 
Loop time of 139.605 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.619 ns/day, 38.779 hours/ns, 7.163 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    | 138.99     | 138.99     | 138.99     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10892    | 0.10892    | 0.10892    |   0.0 |  0.08
Output  | 0.00026168 | 0.00026168 | 0.00026168 |   0.0 |  0.00
Modify  | 0.44146    | 0.44146    | 0.44146    |   0.0 |  0.32
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:      133918.0 ave      133918 max      133918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133918
Ave neighs/atom = 66.959000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.862461813662, Press = -1.01826004710697
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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 
   69000    -13473.34    -13473.34   -13544.987   -13544.987    277.28416    277.28416    31314.212    31314.212   -627.13215   -627.13215 
   70000   -13478.127   -13478.127    -13549.92    -13549.92    277.84709    277.84709    31319.348    31319.348   -1834.6124   -1834.6124 
Loop time of 139.847 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.618 ns/day, 38.847 hours/ns, 7.151 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.23     | 139.23     | 139.23     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10835    | 0.10835    | 0.10835    |   0.0 |  0.08
Output  | 0.00015635 | 0.00015635 | 0.00015635 |   0.0 |  0.00
Modify  | 0.44028    | 0.44028    | 0.44028    |   0.0 |  0.31
Other   |            | 0.06645    |            |       |  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:      134190.0 ave      134190 max      134190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134190
Ave neighs/atom = 67.095000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.903794545059, Press = -1.38532232151154
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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 
   70000   -13478.127   -13478.127    -13549.92    -13549.92    277.84709    277.84709    31319.348    31319.348   -1834.6124   -1834.6124 
   71000   -13475.289   -13475.289   -13546.411   -13546.411    275.25052    275.25052    31319.073    31319.073   -1235.0393   -1235.0393 
Loop time of 139.58 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.619 ns/day, 38.772 hours/ns, 7.164 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    | 138.96     | 138.96     | 138.96     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10916    | 0.10916    | 0.10916    |   0.0 |  0.08
Output  | 0.00015551 | 0.00015551 | 0.00015551 |   0.0 |  0.00
Modify  | 0.43929    | 0.43929    | 0.43929    |   0.0 |  0.31
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:      133820.0 ave      133820 max      133820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 133820
Ave neighs/atom = 66.910000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.922447749394, Press = -1.69993345271239
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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 
   71000   -13475.289   -13475.289   -13546.411   -13546.411    275.25052    275.25052    31319.073    31319.073   -1235.0393   -1235.0393 
   72000    -13478.32    -13478.32   -13546.681   -13546.681    264.56456    264.56456    31302.127    31302.127    21.345891    21.345891 
Loop time of 134.1 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.644 ns/day, 37.250 hours/ns, 7.457 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    | 133.51     | 133.51     | 133.51     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10421    | 0.10421    | 0.10421    |   0.0 |  0.08
Output  | 0.00015796 | 0.00015796 | 0.00015796 |   0.0 |  0.00
Modify  | 0.41771    | 0.41771    | 0.41771    |   0.0 |  0.31
Other   |            | 0.06514    |            |       |  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:      134134.0 ave      134134 max      134134 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134134
Ave neighs/atom = 67.067000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.943934783449, Press = -1.65912024130938
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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 
   72000    -13478.32    -13478.32   -13546.681   -13546.681    264.56456    264.56456    31302.127    31302.127    21.345891    21.345891 
   73000   -13475.621   -13475.621   -13548.665   -13548.665    282.68846    282.68846    31290.038    31290.038    896.12527    896.12527 
Loop time of 119.011 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.059 hours/ns, 8.403 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.51     | 118.51     | 118.51     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092981   | 0.092981   | 0.092981   |   0.0 |  0.08
Output  | 0.00015687 | 0.00015687 | 0.00015687 |   0.0 |  0.00
Modify  | 0.34929    | 0.34929    | 0.34929    |   0.0 |  0.29
Other   |            | 0.06122    |            |       |  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:      134254.0 ave      134254 max      134254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134254
Ave neighs/atom = 67.127000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.978189966945, Press = -1.38433931845957
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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 
   73000   -13475.621   -13475.621   -13548.665   -13548.665    282.68846    282.68846    31290.038    31290.038    896.12527    896.12527 
   74000   -13478.408   -13478.408    -13549.24    -13549.24    274.12782    274.12782    31289.971    31289.971    729.58306    729.58306 
Loop time of 118.757 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.728 ns/day, 32.988 hours/ns, 8.421 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.25     | 118.25     | 118.25     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093605   | 0.093605   | 0.093605   |   0.0 |  0.08
Output  | 0.00015593 | 0.00015593 | 0.00015593 |   0.0 |  0.00
Modify  | 0.34883    | 0.34883    | 0.34883    |   0.0 |  0.29
Other   |            | 0.0608     |            |       |  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:      134078.0 ave      134078 max      134078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134078
Ave neighs/atom = 67.039000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.990819145276, Press = -0.977766209953685
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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 
   74000   -13478.408   -13478.408    -13549.24    -13549.24    274.12782    274.12782    31289.971    31289.971    729.58306    729.58306 
   75000   -13476.165   -13476.165   -13549.185   -13549.185    282.59362    282.59362    31288.026    31288.026    1098.5272    1098.5272 
Loop time of 119.054 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.726 ns/day, 33.070 hours/ns, 8.400 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.55     | 118.55     | 118.55     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093277   | 0.093277   | 0.093277   |   0.0 |  0.08
Output  | 0.0001903  | 0.0001903  | 0.0001903  |   0.0 |  0.00
Modify  | 0.34838    | 0.34838    | 0.34838    |   0.0 |  0.29
Other   |            | 0.06122    |            |       |  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:      134184.0 ave      134184 max      134184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134184
Ave neighs/atom = 67.092000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.000709266113, Press = -0.882195695301706
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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 
   75000   -13476.165   -13476.165   -13549.185   -13549.185    282.59362    282.59362    31288.026    31288.026    1098.5272    1098.5272 
   76000   -13476.169   -13476.169   -13546.892   -13546.892    273.70315    273.70315    31283.432    31283.432    1552.1694    1552.1694 
Loop time of 119.785 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.721 ns/day, 33.273 hours/ns, 8.348 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    | 119.28     | 119.28     | 119.28     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09455    | 0.09455    | 0.09455    |   0.0 |  0.08
Output  | 0.00015483 | 0.00015483 | 0.00015483 |   0.0 |  0.00
Modify  | 0.35258    | 0.35258    | 0.35258    |   0.0 |  0.29
Other   |            | 0.06106    |            |       |  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:      134054.0 ave      134054 max      134054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134054
Ave neighs/atom = 67.027000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.991480558829, Press = -0.7044979609379
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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 
   76000   -13476.169   -13476.169   -13546.892   -13546.892    273.70315    273.70315    31283.432    31283.432    1552.1694    1552.1694 
   77000   -13478.763   -13478.763   -13549.114   -13549.114    272.26522    272.26522    31278.341    31278.341    1740.7775    1740.7775 
Loop time of 138.074 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.626 ns/day, 38.354 hours/ns, 7.243 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    | 137.47     | 137.47     | 137.47     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10806    | 0.10806    | 0.10806    |   0.0 |  0.08
Output  | 0.00020956 | 0.00020956 | 0.00020956 |   0.0 |  0.00
Modify  | 0.43242    | 0.43242    | 0.43242    |   0.0 |  0.31
Other   |            | 0.06579    |            |       |  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:      134534.0 ave      134534 max      134534 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134534
Ave neighs/atom = 67.267000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.99868103389, Press = -0.510506485262753
next a
jump SELF top
variable a loop 2000
run 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.8
  ghost atom cutoff = 6.8
  binsize = 3.4, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.8
      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 
   77000   -13478.763   -13478.763   -13549.114   -13549.114    272.26522    272.26522    31278.341    31278.341    1740.7775    1740.7775 
   78000   -13475.932   -13475.932   -13546.429   -13546.429    272.83198    272.83198    31278.622    31278.622    2038.8565    2038.8565 
Loop time of 133.266 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.648 ns/day, 37.018 hours/ns, 7.504 timesteps/s
99.9% 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.68     | 132.68     | 132.68     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10436    | 0.10436    | 0.10436    |   0.0 |  0.08
Output  | 0.00019788 | 0.00019788 | 0.00019788 |   0.0 |  0.00
Modify  | 0.41554    | 0.41554    | 0.41554    |   0.0 |  0.31
Other   |            | 0.06435    |            |       |  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:      134352.0 ave      134352 max      134352 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0