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

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

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 2.851000025868416*${_u_distance}
variable latticeconst_converted equal 2.851000025868416*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.85100002586842
Lattice spacing in x,y,z = 2.8510000 2.8510000 2.8510000
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 (28.510000 28.510000 28.510000)
  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 (28.510000 28.510000 28.510000)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_EtesamiAsadi_2018_Fe__MO_549900287421_001
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23173.5016817912 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 313.15*${_u_temperature}
variable temp_converted equal 313.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 313.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 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.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  "313.15 - 0.2"
variable      T_up  equal  "313.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_549900287421_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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8499.0847   -8499.0847   -8579.9999   -8579.9999       313.15       313.15    23173.502    23173.502    3729.5625    3729.5625 
    1000   -8412.6757   -8412.6757   -8493.1649   -8493.1649    311.50155    311.50155    23369.527    23369.527     2061.275     2061.275 
Loop time of 125.046 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.691 ns/day, 34.735 hours/ns, 7.997 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.52     | 124.52     | 124.52     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10007    | 0.10007    | 0.10007    |   0.0 |  0.08
Output  | 0.0001999  | 0.0001999  | 0.0001999  |   0.0 |  0.00
Modify  | 0.36808    | 0.36808    | 0.36808    |   0.0 |  0.29
Other   |            | 0.06207    |            |       |  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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8412.6757   -8412.6757   -8493.1649   -8493.1649    311.50155    311.50155    23369.527    23369.527     2061.275     2061.275 
    2000   -8414.4401   -8414.4401   -8495.5994   -8495.5994    314.09493    314.09493    23396.328    23396.328    100.94111    100.94111 
Loop time of 124.983 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.691 ns/day, 34.717 hours/ns, 8.001 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.48     | 124.48     | 124.48     |   0.0 | 99.60
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09792    | 0.09792    | 0.09792    |   0.0 |  0.08
Output  | 0.00019073 | 0.00019073 | 0.00019073 |   0.0 |  0.00
Modify  | 0.34817    | 0.34817    | 0.34817    |   0.0 |  0.28
Other   |            | 0.05941    |            |       |  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:      128230.0 ave      128230 max      128230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128230
Ave neighs/atom = 64.115000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8414.4401   -8414.4401   -8495.5994   -8495.5994    314.09493    314.09493    23396.328    23396.328    100.94111    100.94111 
    3000   -8414.4962   -8414.4962   -8494.3671   -8494.3671    309.10864    309.10864    23412.039    23412.039   -1206.9894   -1206.9894 
Loop time of 128.896 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.670 ns/day, 35.805 hours/ns, 7.758 timesteps/s
99.9% 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.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09997    | 0.09997    | 0.09997    |   0.0 |  0.08
Output  | 0.00019283 | 0.00019283 | 0.00019283 |   0.0 |  0.00
Modify  | 0.36384    | 0.36384    | 0.36384    |   0.0 |  0.28
Other   |            | 0.06162    |            |       |  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:      128280.0 ave      128280 max      128280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128280
Ave neighs/atom = 64.140000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8414.4962   -8414.4962   -8494.3671   -8494.3671    309.10864    309.10864    23412.039    23412.039   -1206.9894   -1206.9894 
    4000   -8412.7934   -8412.7934   -8494.3769   -8494.3769    315.73679    315.73679     23410.89     23410.89   -918.58979   -918.58979 
Loop time of 127.969 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.675 ns/day, 35.547 hours/ns, 7.814 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.45     | 127.45     | 127.45     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10033    | 0.10033    | 0.10033    |   0.0 |  0.08
Output  | 0.0001927  | 0.0001927  | 0.0001927  |   0.0 |  0.00
Modify  | 0.36126    | 0.36126    | 0.36126    |   0.0 |  0.28
Other   |            | 0.06095    |            |       |  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:      128212.0 ave      128212 max      128212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128212
Ave neighs/atom = 64.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 = 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8412.7934   -8412.7934   -8494.3769   -8494.3769    315.73679    315.73679     23410.89     23410.89   -918.58979   -918.58979 
    5000   -8415.3081   -8415.3081   -8495.3632   -8495.3632    309.82154    309.82154    23383.652    23383.652    756.32269    756.32269 
Loop time of 139.875 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.29     | 139.29     | 139.29     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10852    | 0.10852    | 0.10852    |   0.0 |  0.08
Output  | 0.00020678 | 0.00020678 | 0.00020678 |   0.0 |  0.00
Modify  | 0.411      | 0.411      | 0.411      |   0.0 |  0.29
Other   |            | 0.06431    |            |       |  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:      128214.0 ave      128214 max      128214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128214
Ave neighs/atom = 64.107000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.139536876225, Press = 1522.65086027061
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8415.3081   -8415.3081   -8495.3632   -8495.3632    309.82154    309.82154    23383.652    23383.652    756.32269    756.32269 
    6000   -8413.2609   -8413.2609   -8495.4713   -8495.4713    318.16289    318.16289    23361.654    23361.654    2534.5266    2534.5266 
Loop time of 124.054 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.696 ns/day, 34.460 hours/ns, 8.061 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    | 123.53     | 123.53     | 123.53     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097349   | 0.097349   | 0.097349   |   0.0 |  0.08
Output  | 0.00015487 | 0.00015487 | 0.00015487 |   0.0 |  0.00
Modify  | 0.36311    | 0.36311    | 0.36311    |   0.0 |  0.29
Other   |            | 0.05962    |            |       |  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:      128252.0 ave      128252 max      128252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128252
Ave neighs/atom = 64.126000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.270457352559, Press = 112.991543640426
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8413.2609   -8413.2609   -8495.4713   -8495.4713    318.16289    318.16289    23361.654    23361.654    2534.5266    2534.5266 
    7000   -8415.8968   -8415.8968   -8494.8899   -8494.8899    305.71136    305.71136    23344.003    23344.003    3703.8885    3703.8885 
Loop time of 136.189 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.634 ns/day, 37.830 hours/ns, 7.343 timesteps/s
99.9% 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.61     | 135.61     | 135.61     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10485    | 0.10485    | 0.10485    |   0.0 |  0.08
Output  | 0.00015461 | 0.00015461 | 0.00015461 |   0.0 |  0.00
Modify  | 0.41338    | 0.41338    | 0.41338    |   0.0 |  0.30
Other   |            | 0.06306    |            |       |  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:      128258.0 ave      128258 max      128258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128258
Ave neighs/atom = 64.129000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.212279464071, Press = 29.4933300642655
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8415.8968   -8415.8968   -8494.8899   -8494.8899    305.71136    305.71136    23344.003    23344.003    3703.8885    3703.8885 
    8000   -8409.6301   -8409.6301   -8491.1551   -8491.1551    315.51023    315.51023    23383.844    23383.844    1466.0148    1466.0148 
Loop time of 130.69 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.661 ns/day, 36.303 hours/ns, 7.652 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.14     | 130.14     | 130.14     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10113    | 0.10113    | 0.10113    |   0.0 |  0.08
Output  | 0.00015411 | 0.00015411 | 0.00015411 |   0.0 |  0.00
Modify  | 0.39067    | 0.39067    | 0.39067    |   0.0 |  0.30
Other   |            | 0.06192    |            |       |  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:      128256.0 ave      128256 max      128256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128256
Ave neighs/atom = 64.128000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.841383797953, Press = 10.0847765894401
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8409.6301   -8409.6301   -8491.1551   -8491.1551    315.51023    315.51023    23383.844    23383.844    1466.0148    1466.0148 
    9000   -8415.5697   -8415.5697   -8494.9274   -8494.9274    307.12263    307.12263    23394.514    23394.514    63.881287    63.881287 
Loop time of 121.42 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.712 ns/day, 33.728 hours/ns, 8.236 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.91     | 120.91     | 120.91     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09563    | 0.09563    | 0.09563    |   0.0 |  0.08
Output  | 0.00018806 | 0.00018806 | 0.00018806 |   0.0 |  0.00
Modify  | 0.35069    | 0.35069    | 0.35069    |   0.0 |  0.29
Other   |            | 0.05883    |            |       |  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:      128358.0 ave      128358 max      128358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128358
Ave neighs/atom = 64.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 = 313.910838723224, Press = 8.86680707454418
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8415.5697   -8415.5697   -8494.9274   -8494.9274    307.12263    307.12263    23394.514    23394.514    63.881287    63.881287 
   10000   -8411.0107   -8411.0107   -8493.5214   -8493.5214    319.32492    319.32492    23419.867    23419.867   -1350.2012   -1350.2012 
Loop time of 121.53 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.758 hours/ns, 8.228 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.02     | 121.02     | 121.02     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095239   | 0.095239   | 0.095239   |   0.0 |  0.08
Output  | 0.00015884 | 0.00015884 | 0.00015884 |   0.0 |  0.00
Modify  | 0.35141    | 0.35141    | 0.35141    |   0.0 |  0.29
Other   |            | 0.05847    |            |       |  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:      128228.0 ave      128228 max      128228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128228
Ave neighs/atom = 64.114000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.130499683781, Press = 10.4279213174691
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8411.0107   -8411.0107   -8493.5214   -8493.5214    319.32492    319.32492    23419.867    23419.867   -1350.2012   -1350.2012 
   11000   -8416.4922   -8416.4922   -8497.5884   -8497.5884    313.85092    313.85092     23422.23     23422.23   -2280.5036   -2280.5036 
Loop time of 121.531 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.759 hours/ns, 8.228 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.03     | 121.03     | 121.03     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095382   | 0.095382   | 0.095382   |   0.0 |  0.08
Output  | 0.0001558  | 0.0001558  | 0.0001558  |   0.0 |  0.00
Modify  | 0.35023    | 0.35023    | 0.35023    |   0.0 |  0.29
Other   |            | 0.0588     |            |       |  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:      128266.0 ave      128266 max      128266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128266
Ave neighs/atom = 64.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 = 314.120110079881, Press = 17.3569145635958
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8416.4922   -8416.4922   -8497.5884   -8497.5884    313.85092    313.85092     23422.23     23422.23   -2280.5036   -2280.5036 
   12000   -8412.3555   -8412.3555    -8495.556    -8495.556     321.9945     321.9945     23395.57     23395.57    113.03184    113.03184 
Loop time of 124.545 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.694 ns/day, 34.596 hours/ns, 8.029 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.03     | 124.03     | 124.03     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097498   | 0.097498   | 0.097498   |   0.0 |  0.08
Output  | 0.0001875  | 0.0001875  | 0.0001875  |   0.0 |  0.00
Modify  | 0.3618     | 0.3618     | 0.3618     |   0.0 |  0.29
Other   |            | 0.05896    |            |       |  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:      128216.0 ave      128216 max      128216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128216
Ave neighs/atom = 64.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 = 314.217582169014, Press = 31.4234317946008
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8412.3555   -8412.3555    -8495.556    -8495.556     321.9945     321.9945     23395.57     23395.57    113.03184    113.03184 
   13000    -8413.456    -8413.456   -8493.8622   -8493.8622    311.18064    311.18064    23367.771    23367.771    2183.6768    2183.6768 
Loop time of 127.878 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.676 ns/day, 35.522 hours/ns, 7.820 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.34     | 127.34     | 127.34     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099948   | 0.099948   | 0.099948   |   0.0 |  0.08
Output  | 0.00015532 | 0.00015532 | 0.00015532 |   0.0 |  0.00
Modify  | 0.37748    | 0.37748    | 0.37748    |   0.0 |  0.30
Other   |            | 0.0598     |            |       |  0.05

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

Total # of neighbors = 128216
Ave neighs/atom = 64.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 = 314.218513360556, Press = 15.5342358437642
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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    -8413.456    -8413.456   -8493.8622   -8493.8622    311.18064    311.18064    23367.771    23367.771    2183.6768    2183.6768 
   14000   -8415.6923   -8415.6923   -8496.7774   -8496.7774    313.80757    313.80757    23374.401    23374.401    1362.8878    1362.8878 
Loop time of 123.294 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.701 ns/day, 34.248 hours/ns, 8.111 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.78     | 122.78     | 122.78     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096837   | 0.096837   | 0.096837   |   0.0 |  0.08
Output  | 0.00015484 | 0.00015484 | 0.00015484 |   0.0 |  0.00
Modify  | 0.35697    | 0.35697    | 0.35697    |   0.0 |  0.29
Other   |            | 0.05825    |            |       |  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:      128280.0 ave      128280 max      128280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128280
Ave neighs/atom = 64.140000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.34997287957, Press = 5.5744500846664
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8415.6923   -8415.6923   -8496.7774   -8496.7774    313.80757    313.80757    23374.401    23374.401    1362.8878    1362.8878 
   15000   -8410.1687   -8410.1687   -8491.9886   -8491.9886     316.6515     316.6515    23402.007    23402.007     80.11088     80.11088 
Loop time of 122.026 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.708 ns/day, 33.896 hours/ns, 8.195 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.52     | 121.52     | 121.52     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095935   | 0.095935   | 0.095935   |   0.0 |  0.08
Output  | 0.00020528 | 0.00020528 | 0.00020528 |   0.0 |  0.00
Modify  | 0.35271    | 0.35271    | 0.35271    |   0.0 |  0.29
Other   |            | 0.05845    |            |       |  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:      128246.0 ave      128246 max      128246 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128246
Ave neighs/atom = 64.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 = 314.275541539248, Press = 2.91598715479886
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8410.1687   -8410.1687   -8491.9886   -8491.9886     316.6515     316.6515    23402.007    23402.007     80.11088     80.11088 
   16000   -8415.1962   -8415.1962   -8496.5894   -8496.5894    315.00014    315.00014    23429.046    23429.046    -2495.703    -2495.703 
Loop time of 127.011 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.680 ns/day, 35.281 hours/ns, 7.873 timesteps/s
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.48     | 126.48     | 126.48     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099419   | 0.099419   | 0.099419   |   0.0 |  0.08
Output  | 0.00015296 | 0.00015296 | 0.00015296 |   0.0 |  0.00
Modify  | 0.37423    | 0.37423    | 0.37423    |   0.0 |  0.29
Other   |            | 0.06032    |            |       |  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:      128244.0 ave      128244 max      128244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128244
Ave neighs/atom = 64.122000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.368926268096, Press = 1.00609795764504
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8415.1962   -8415.1962   -8496.5894   -8496.5894    315.00014    315.00014    23429.046    23429.046    -2495.703    -2495.703 
   17000   -8412.1506   -8412.1506   -8494.3174   -8494.3174    317.99391    317.99391    23469.495    23469.495   -5025.0011   -5025.0011 
Loop time of 123.221 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.701 ns/day, 34.228 hours/ns, 8.116 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 122.71     | 122.71     | 122.71     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096759   | 0.096759   | 0.096759   |   0.0 |  0.08
Output  | 0.00018988 | 0.00018988 | 0.00018988 |   0.0 |  0.00
Modify  | 0.35766    | 0.35766    | 0.35766    |   0.0 |  0.29
Other   |            | 0.05867    |            |       |  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:      128192.0 ave      128192 max      128192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128192
Ave neighs/atom = 64.096000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.432491862465, Press = 6.74634770266497
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8412.1506   -8412.1506   -8494.3174   -8494.3174    317.99391    317.99391    23469.495    23469.495   -5025.0011   -5025.0011 
   18000    -8413.594    -8413.594   -8496.1275   -8496.1275    319.41303    319.41303    23425.283    23425.283   -2109.3697   -2109.3697 
Loop time of 126.028 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.686 ns/day, 35.008 hours/ns, 7.935 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.5      | 125.5      | 125.5      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09844    | 0.09844    | 0.09844    |   0.0 |  0.08
Output  | 0.0001553  | 0.0001553  | 0.0001553  |   0.0 |  0.00
Modify  | 0.37073    | 0.37073    | 0.37073    |   0.0 |  0.29
Other   |            | 0.06047    |            |       |  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:      128174.0 ave      128174 max      128174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128174
Ave neighs/atom = 64.087000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 314.227811985019, Press = 10.4240104120085
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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    -8413.594    -8413.594   -8496.1275   -8496.1275    319.41303    319.41303    23425.283    23425.283   -2109.3697   -2109.3697 
   19000   -8418.6231   -8418.6231   -8497.6295   -8497.6295    305.76313    305.76313    23382.606    23382.606    576.85067    576.85067 
Loop time of 133.711 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.646 ns/day, 37.142 hours/ns, 7.479 timesteps/s
99.9% 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.14     | 133.14     | 133.14     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10578    | 0.10578    | 0.10578    |   0.0 |  0.08
Output  | 0.00015591 | 0.00015591 | 0.00015591 |   0.0 |  0.00
Modify  | 0.40685    | 0.40685    | 0.40685    |   0.0 |  0.30
Other   |            | 0.06337    |            |       |  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:      128212.0 ave      128212 max      128212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128212
Ave neighs/atom = 64.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 = 314.044215820055, Press = 9.49250655690366
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8418.6231   -8418.6231   -8497.6295   -8497.6295    305.76313    305.76313    23382.606    23382.606    576.85067    576.85067 
   20000   -8415.2538   -8415.2538   -8495.9186   -8495.9186    312.18101    312.18101    23364.585    23364.585    2326.4271    2326.4271 
Loop time of 123.374 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.271 hours/ns, 8.105 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.86     | 122.86     | 122.86     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098862   | 0.098862   | 0.098862   |   0.0 |  0.08
Output  | 0.00015306 | 0.00015306 | 0.00015306 |   0.0 |  0.00
Modify  | 0.35998    | 0.35998    | 0.35998    |   0.0 |  0.29
Other   |            | 0.06       |            |       |  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:      128186.0 ave      128186 max      128186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128186
Ave neighs/atom = 64.093000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.936423729353, Press = 7.97378033780276
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8415.2538   -8415.2538   -8495.9186   -8495.9186    312.18101    312.18101    23364.585    23364.585    2326.4271    2326.4271 
   21000   -8413.1564   -8413.1564   -8497.6141   -8497.6141    326.85982    326.85982    23367.479    23367.479    1904.3679    1904.3679 
Loop time of 130.662 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.11     | 130.11     | 130.11     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10224    | 0.10224    | 0.10224    |   0.0 |  0.08
Output  | 0.00019244 | 0.00019244 | 0.00019244 |   0.0 |  0.00
Modify  | 0.39138    | 0.39138    | 0.39138    |   0.0 |  0.30
Other   |            | 0.06208    |            |       |  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:      128274.0 ave      128274 max      128274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128274
Ave neighs/atom = 64.137000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.99811661556, Press = 3.68447916065262
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8413.1564   -8413.1564   -8497.6141   -8497.6141    326.85982    326.85982    23367.479    23367.479    1904.3679    1904.3679 
   22000   -8414.7619   -8414.7619    -8494.884    -8494.884    310.08069    310.08069    23385.118    23385.118    921.91175    921.91175 
Loop time of 121.984 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.708 ns/day, 33.884 hours/ns, 8.198 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.47     | 121.47     | 121.47     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096345   | 0.096345   | 0.096345   |   0.0 |  0.08
Output  | 0.00018949 | 0.00018949 | 0.00018949 |   0.0 |  0.00
Modify  | 0.35394    | 0.35394    | 0.35394    |   0.0 |  0.29
Other   |            | 0.05858    |            |       |  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:      128280.0 ave      128280 max      128280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128280
Ave neighs/atom = 64.140000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.881865043623, Press = 1.23456292235001
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8414.7619   -8414.7619    -8494.884    -8494.884    310.08069    310.08069    23385.118    23385.118    921.91175    921.91175 
   23000    -8417.106    -8417.106   -8494.7634   -8494.7634    300.54205    300.54205    23405.041    23405.041   -705.97919   -705.97919 
Loop time of 121.11 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.642 hours/ns, 8.257 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.61     | 120.61     | 120.61     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095086   | 0.095086   | 0.095086   |   0.0 |  0.08
Output  | 0.00018912 | 0.00018912 | 0.00018912 |   0.0 |  0.00
Modify  | 0.34966    | 0.34966    | 0.34966    |   0.0 |  0.29
Other   |            | 0.05853    |            |       |  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:      128232.0 ave      128232 max      128232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128232
Ave neighs/atom = 64.116000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.8285792089, Press = -2.05832852091215
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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    -8417.106    -8417.106   -8494.7634   -8494.7634    300.54205    300.54205    23405.041    23405.041   -705.97919   -705.97919 
   24000   -8411.3955   -8411.3955   -8494.0408   -8494.0408    319.84589    319.84589    23445.028    23445.028   -3287.2067   -3287.2067 
Loop time of 121.197 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.666 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.69     | 120.69     | 120.69     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095865   | 0.095865   | 0.095865   |   0.0 |  0.08
Output  | 0.00015361 | 0.00015361 | 0.00015361 |   0.0 |  0.00
Modify  | 0.34943    | 0.34943    | 0.34943    |   0.0 |  0.29
Other   |            | 0.05801    |            |       |  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:      128204.0 ave      128204 max      128204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128204
Ave neighs/atom = 64.102000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.745755877365, Press = 0.955293706489013
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8411.3955   -8411.3955   -8494.0408   -8494.0408    319.84589    319.84589    23445.028    23445.028   -3287.2067   -3287.2067 
   25000    -8414.518    -8414.518   -8492.1108   -8492.1108     300.2919     300.2919    23427.219    23427.219   -1923.1406   -1923.1406 
Loop time of 121.436 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.732 hours/ns, 8.235 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.93     | 120.93     | 120.93     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095014   | 0.095014   | 0.095014   |   0.0 |  0.08
Output  | 0.00015397 | 0.00015397 | 0.00015397 |   0.0 |  0.00
Modify  | 0.34949    | 0.34949    | 0.34949    |   0.0 |  0.29
Other   |            | 0.05819    |            |       |  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:      128242.0 ave      128242 max      128242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128242
Ave neighs/atom = 64.121000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.699142747198, Press = 3.88622245383684
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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    -8414.518    -8414.518   -8492.1108   -8492.1108     300.2919     300.2919    23427.219    23427.219   -1923.1406   -1923.1406 
   26000   -8416.0261   -8416.0261   -8497.9816   -8497.9816    317.17641    317.17641     23413.51     23413.51    -1658.908    -1658.908 
Loop time of 121.056 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.627 hours/ns, 8.261 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.55     | 120.55     | 120.55     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095562   | 0.095562   | 0.095562   |   0.0 |  0.08
Output  | 0.00015425 | 0.00015425 | 0.00015425 |   0.0 |  0.00
Modify  | 0.3494     | 0.3494     | 0.3494     |   0.0 |  0.29
Other   |            | 0.05808    |            |       |  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:      128298.0 ave      128298 max      128298 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128298
Ave neighs/atom = 64.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 = 313.74028945566, Press = 5.25299435230329
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8416.0261   -8416.0261   -8497.9816   -8497.9816    317.17641    317.17641     23413.51     23413.51    -1658.908    -1658.908 
   27000   -8413.0339   -8413.0339   -8493.2532   -8493.2532    310.45707    310.45707    23395.589    23395.589    260.69941    260.69941 
Loop time of 121.387 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.712 ns/day, 33.719 hours/ns, 8.238 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.88     | 120.88     | 120.88     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095203   | 0.095203   | 0.095203   |   0.0 |  0.08
Output  | 0.00015612 | 0.00015612 | 0.00015612 |   0.0 |  0.00
Modify  | 0.3499     | 0.3499     | 0.3499     |   0.0 |  0.29
Other   |            | 0.05821    |            |       |  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:      128254.0 ave      128254 max      128254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128254
Ave neighs/atom = 64.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 = 313.675507927078, Press = 5.8747044490028
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8413.0339   -8413.0339   -8493.2532   -8493.2532    310.45707    310.45707    23395.589    23395.589    260.69941    260.69941 
   28000   -8415.8019   -8415.8019   -8494.6023   -8494.6023    304.96547    304.96547     23367.85     23367.85    1967.2927    1967.2927 
Loop time of 120.889 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.715 ns/day, 33.580 hours/ns, 8.272 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.38     | 120.38     | 120.38     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095864   | 0.095864   | 0.095864   |   0.0 |  0.08
Output  | 0.00015394 | 0.00015394 | 0.00015394 |   0.0 |  0.00
Modify  | 0.35019    | 0.35019    | 0.35019    |   0.0 |  0.29
Other   |            | 0.05839    |            |       |  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:      128260.0 ave      128260 max      128260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128260
Ave neighs/atom = 64.130000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.678444222529, Press = 6.34232222978225
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8415.8019   -8415.8019   -8494.6023   -8494.6023    304.96547    304.96547     23367.85     23367.85    1967.2927    1967.2927 
   29000   -8413.7058   -8413.7058   -8495.3479   -8495.3479    315.96343    315.96343    23322.762    23322.762    5370.3242    5370.3242 
Loop time of 121.506 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.752 hours/ns, 8.230 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        | 121        | 121        |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095505   | 0.095505   | 0.095505   |   0.0 |  0.08
Output  | 0.00015344 | 0.00015344 | 0.00015344 |   0.0 |  0.00
Modify  | 0.34926    | 0.34926    | 0.34926    |   0.0 |  0.29
Other   |            | 0.05836    |            |       |  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:      128280.0 ave      128280 max      128280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128280
Ave neighs/atom = 64.140000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.62334566697, Press = 4.77563741515524
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8413.7058   -8413.7058   -8495.3479   -8495.3479    315.96343    315.96343    23322.762    23322.762    5370.3242    5370.3242 
   30000   -8413.1553   -8413.1553   -8493.1732   -8493.1732    309.67757    309.67757    23365.568    23365.568    2457.2825    2457.2825 
Loop time of 121.608 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.710 ns/day, 33.780 hours/ns, 8.223 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.1      | 121.1      | 121.1      |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095612   | 0.095612   | 0.095612   |   0.0 |  0.08
Output  | 0.00042759 | 0.00042759 | 0.00042759 |   0.0 |  0.00
Modify  | 0.34916    | 0.34916    | 0.34916    |   0.0 |  0.29
Other   |            | 0.05821    |            |       |  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:      128304.0 ave      128304 max      128304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128304
Ave neighs/atom = 64.152000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.599008666781, Press = 1.75209882728296
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8413.1553   -8413.1553   -8493.1732   -8493.1732    309.67757    309.67757    23365.568    23365.568    2457.2825    2457.2825 
   31000   -8416.6058   -8416.6058   -8495.8258   -8495.8258     306.5895     306.5895    23391.972    23391.972    73.246821    73.246821 
Loop time of 121.509 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.752 hours/ns, 8.230 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.01     | 121.01     | 121.01     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095483   | 0.095483   | 0.095483   |   0.0 |  0.08
Output  | 0.00015402 | 0.00015402 | 0.00015402 |   0.0 |  0.00
Modify  | 0.34865    | 0.34865    | 0.34865    |   0.0 |  0.29
Other   |            | 0.05838    |            |       |  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:      128272.0 ave      128272 max      128272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128272
Ave neighs/atom = 64.136000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.558106363398, Press = 0.637091889677622
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8416.6058   -8416.6058   -8495.8258   -8495.8258     306.5895     306.5895    23391.972    23391.972    73.246821    73.246821 
   32000   -8412.5178   -8412.5178   -8494.5394   -8494.5394    317.43227    317.43227    23416.833    23416.833   -1383.7281   -1383.7281 
Loop time of 121.281 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.712 ns/day, 33.689 hours/ns, 8.245 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.78     | 120.78     | 120.78     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095399   | 0.095399   | 0.095399   |   0.0 |  0.08
Output  | 0.00015578 | 0.00015578 | 0.00015578 |   0.0 |  0.00
Modify  | 0.35076    | 0.35076    | 0.35076    |   0.0 |  0.29
Other   |            | 0.0588     |            |       |  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:      128266.0 ave      128266 max      128266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128266
Ave neighs/atom = 64.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 = 313.46704614109, Press = 2.02246108910012
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8412.5178   -8412.5178   -8494.5394   -8494.5394    317.43227    317.43227    23416.833    23416.833   -1383.7281   -1383.7281 
   33000   -8412.4906   -8412.4906    -8493.361    -8493.361    312.97653    312.97653    23429.414    23429.414   -2105.8102   -2105.8102 
Loop time of 120.949 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.597 hours/ns, 8.268 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.44     | 120.44     | 120.44     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09567    | 0.09567    | 0.09567    |   0.0 |  0.08
Output  | 0.00015721 | 0.00015721 | 0.00015721 |   0.0 |  0.00
Modify  | 0.35048    | 0.35048    | 0.35048    |   0.0 |  0.29
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:      128242.0 ave      128242 max      128242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128242
Ave neighs/atom = 64.121000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.472651298541, Press = 3.17004905510207
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8412.4906   -8412.4906    -8493.361    -8493.361    312.97653    312.97653    23429.414    23429.414   -2105.8102   -2105.8102 
   34000   -8416.9051   -8416.9051   -8497.8019   -8497.8019    313.07916    313.07916    23437.305    23437.305   -3398.7788   -3398.7788 
Loop time of 121.247 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.680 hours/ns, 8.248 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.74     | 120.74     | 120.74     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096497   | 0.096497   | 0.096497   |   0.0 |  0.08
Output  | 0.0001972  | 0.0001972  | 0.0001972  |   0.0 |  0.00
Modify  | 0.35103    | 0.35103    | 0.35103    |   0.0 |  0.29
Other   |            | 0.05893    |            |       |  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:      128230.0 ave      128230 max      128230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128230
Ave neighs/atom = 64.115000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.427195095334, Press = 6.01451118564988
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8416.9051   -8416.9051   -8497.8019   -8497.8019    313.07916    313.07916    23437.305    23437.305   -3398.7788   -3398.7788 
   35000   -8413.1017   -8413.1017   -8493.4615   -8493.4615    311.00065    311.00065    23397.633    23397.633    122.49065    122.49065 
Loop time of 121.182 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.662 hours/ns, 8.252 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.68     | 120.68     | 120.68     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096158   | 0.096158   | 0.096158   |   0.0 |  0.08
Output  | 0.00020054 | 0.00020054 | 0.00020054 |   0.0 |  0.00
Modify  | 0.34988    | 0.34988    | 0.34988    |   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:      128178.0 ave      128178 max      128178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128178
Ave neighs/atom = 64.089000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.40694909749, Press = 5.89245488592659
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8413.1017   -8413.1017   -8493.4615   -8493.4615    311.00065    311.00065    23397.633    23397.633    122.49065    122.49065 
   36000   -8414.6127   -8414.6127   -8497.0087   -8497.0087    318.88087    318.88087    23383.998    23383.998    673.13382    673.13382 
Loop time of 121.661 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.710 ns/day, 33.795 hours/ns, 8.220 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.16     | 121.16     | 121.16     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095819   | 0.095819   | 0.095819   |   0.0 |  0.08
Output  | 0.00015522 | 0.00015522 | 0.00015522 |   0.0 |  0.00
Modify  | 0.35073    | 0.35073    | 0.35073    |   0.0 |  0.29
Other   |            | 0.05843    |            |       |  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:      128252.0 ave      128252 max      128252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128252
Ave neighs/atom = 64.126000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.41065221205, Press = 4.04483634596809
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8414.6127   -8414.6127   -8497.0087   -8497.0087    318.88087    318.88087    23383.998    23383.998    673.13382    673.13382 
   37000   -8409.9075   -8409.9075   -8490.8037   -8490.8037    313.07636    313.07636    23380.884    23380.884    1849.3052    1849.3052 
Loop time of 121.499 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.750 hours/ns, 8.231 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.99     | 120.99     | 120.99     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095952   | 0.095952   | 0.095952   |   0.0 |  0.08
Output  | 0.00019188 | 0.00019188 | 0.00019188 |   0.0 |  0.00
Modify  | 0.35224    | 0.35224    | 0.35224    |   0.0 |  0.29
Other   |            | 0.05844    |            |       |  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:      128216.0 ave      128216 max      128216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128216
Ave neighs/atom = 64.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 = 313.454680014035, Press = 3.13310622947678
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8409.9075   -8409.9075   -8490.8037   -8490.8037    313.07636    313.07636    23380.884    23380.884    1849.3052    1849.3052 
   38000   -8414.9143   -8414.9143   -8495.3271   -8495.3271    311.20574    311.20574    23367.708    23367.708    2103.5137    2103.5137 
Loop time of 121.335 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.712 ns/day, 33.704 hours/ns, 8.242 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.83     | 120.83     | 120.83     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095222   | 0.095222   | 0.095222   |   0.0 |  0.08
Output  | 0.00015618 | 0.00015618 | 0.00015618 |   0.0 |  0.00
Modify  | 0.35058    | 0.35058    | 0.35058    |   0.0 |  0.29
Other   |            | 0.05888    |            |       |  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:      128320.0 ave      128320 max      128320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128320
Ave neighs/atom = 64.160000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.511940158496, Press = 1.85294519425609
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8414.9143   -8414.9143   -8495.3271   -8495.3271    311.20574    311.20574    23367.708    23367.708    2103.5137    2103.5137 
   39000   -8408.0146   -8408.0146   -8491.4605   -8491.4605    322.94437    322.94437    23387.807    23387.807    1480.6508    1480.6508 
Loop time of 125.059 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.691 ns/day, 34.739 hours/ns, 7.996 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.53     | 124.53     | 124.53     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098698   | 0.098698   | 0.098698   |   0.0 |  0.08
Output  | 0.00015633 | 0.00015633 | 0.00015633 |   0.0 |  0.00
Modify  | 0.36731    | 0.36731    | 0.36731    |   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:      128252.0 ave      128252 max      128252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128252
Ave neighs/atom = 64.126000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.557244674513, Press = -0.149819442957414
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8408.0146   -8408.0146   -8491.4605   -8491.4605    322.94437    322.94437    23387.807    23387.807    1480.6508    1480.6508 
   40000   -8414.6076   -8414.6076   -8495.6958   -8495.6958    313.81981    313.81981    23410.741    23410.741   -1018.0742   -1018.0742 
Loop time of 139.184 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.621 ns/day, 38.662 hours/ns, 7.185 timesteps/s
99.9% 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.58     | 138.58     | 138.58     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10779    | 0.10779    | 0.10779    |   0.0 |  0.08
Output  | 0.00015462 | 0.00015462 | 0.00015462 |   0.0 |  0.00
Modify  | 0.42692    | 0.42692    | 0.42692    |   0.0 |  0.31
Other   |            | 0.06477    |            |       |  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:      128286.0 ave      128286 max      128286 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128286
Ave neighs/atom = 64.143000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.594146316382, Press = 0.558922902058885
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8414.6076   -8414.6076   -8495.6958   -8495.6958    313.81981    313.81981    23410.741    23410.741   -1018.0742   -1018.0742 
   41000   -8412.9518   -8412.9518   -8492.8434   -8492.8434     309.1886     309.1886    23418.529    23418.529   -1382.4879   -1382.4879 
Loop time of 139.923 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.617 ns/day, 38.868 hours/ns, 7.147 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    | 139.32     | 139.32     | 139.32     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1077     | 0.1077     | 0.1077     |   0.0 |  0.08
Output  | 0.00015426 | 0.00015426 | 0.00015426 |   0.0 |  0.00
Modify  | 0.42931    | 0.42931    | 0.42931    |   0.0 |  0.31
Other   |            | 0.06424    |            |       |  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:      128224.0 ave      128224 max      128224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128224
Ave neighs/atom = 64.112000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.627963282434, Press = 2.02658035211214
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8412.9518   -8412.9518   -8492.8434   -8492.8434     309.1886     309.1886    23418.529    23418.529   -1382.4879   -1382.4879 
   42000   -8412.5362   -8412.5362   -8494.2899   -8494.2899    316.39545    316.39545    23418.902    23418.902   -1413.7643   -1413.7643 
Loop time of 121.261 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.684 hours/ns, 8.247 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.76     | 120.76     | 120.76     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095738   | 0.095738   | 0.095738   |   0.0 |  0.08
Output  | 0.00015502 | 0.00015502 | 0.00015502 |   0.0 |  0.00
Modify  | 0.35016    | 0.35016    | 0.35016    |   0.0 |  0.29
Other   |            | 0.05855    |            |       |  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:      128224.0 ave      128224 max      128224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128224
Ave neighs/atom = 64.112000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.629811080982, Press = 2.58837965531159
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8412.5362   -8412.5362   -8494.2899   -8494.2899    316.39545    316.39545    23418.902    23418.902   -1413.7643   -1413.7643 
   43000    -8413.135    -8413.135   -8495.8228   -8495.8228    320.01025    320.01025    23420.459    23420.459   -1772.9425   -1772.9425 
Loop time of 121.575 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.771 hours/ns, 8.225 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.07     | 121.07     | 121.07     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096061   | 0.096061   | 0.096061   |   0.0 |  0.08
Output  | 0.00019558 | 0.00019558 | 0.00019558 |   0.0 |  0.00
Modify  | 0.35136    | 0.35136    | 0.35136    |   0.0 |  0.29
Other   |            | 0.05837    |            |       |  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:      128238.0 ave      128238 max      128238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128238
Ave neighs/atom = 64.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 = 313.699156318425, Press = 2.74368422751722
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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    -8413.135    -8413.135   -8495.8228   -8495.8228    320.01025    320.01025    23420.459    23420.459   -1772.9425   -1772.9425 
   44000   -8412.0901   -8412.0901   -8494.0043   -8494.0043    317.01656    317.01656    23427.313    23427.313   -1965.6555   -1965.6555 
Loop time of 121.37 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.712 ns/day, 33.714 hours/ns, 8.239 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.87     | 120.87     | 120.87     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095635   | 0.095635   | 0.095635   |   0.0 |  0.08
Output  | 0.00015595 | 0.00015595 | 0.00015595 |   0.0 |  0.00
Modify  | 0.35078    | 0.35078    | 0.35078    |   0.0 |  0.29
Other   |            | 0.05839    |            |       |  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:      128190.0 ave      128190 max      128190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128190
Ave neighs/atom = 64.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 = 313.71591843999, Press = 3.77859974805458
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8412.0901   -8412.0901   -8494.0043   -8494.0043    317.01656    317.01656    23427.313    23427.313   -1965.6555   -1965.6555 
   45000    -8416.781    -8416.781   -8495.9687   -8495.9687    306.46461    306.46461    23384.702    23384.702     640.6626     640.6626 
Loop time of 121.819 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.709 ns/day, 33.839 hours/ns, 8.209 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.31     | 121.31     | 121.31     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096455   | 0.096455   | 0.096455   |   0.0 |  0.08
Output  | 0.00015549 | 0.00015549 | 0.00015549 |   0.0 |  0.00
Modify  | 0.35333    | 0.35333    | 0.35333    |   0.0 |  0.29
Other   |            | 0.05835    |            |       |  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:      128220.0 ave      128220 max      128220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128220
Ave neighs/atom = 64.110000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.747375500219, Press = 5.19508621741611
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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    -8416.781    -8416.781   -8495.9687   -8495.9687    306.46461    306.46461    23384.702    23384.702     640.6626     640.6626 
   46000   -8413.0877   -8413.0877   -8494.8223   -8494.8223    316.32148    316.32148     23363.54     23363.54    2487.2419    2487.2419 
Loop time of 132.409 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.653 ns/day, 36.780 hours/ns, 7.552 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.85     | 131.85     | 131.85     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10425    | 0.10425    | 0.10425    |   0.0 |  0.08
Output  | 0.0001876  | 0.0001876  | 0.0001876  |   0.0 |  0.00
Modify  | 0.39651    | 0.39651    | 0.39651    |   0.0 |  0.30
Other   |            | 0.06244    |            |       |  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:      128210.0 ave      128210 max      128210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128210
Ave neighs/atom = 64.105000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.690863268396, Press = 3.56192456900796
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8413.0877   -8413.0877   -8494.8223   -8494.8223    316.32148    316.32148     23363.54     23363.54    2487.2419    2487.2419 
   47000   -8412.3615   -8412.3615   -8495.4987   -8495.4987    321.74937    321.74937    23376.935    23376.935    1529.5758    1529.5758 
Loop time of 127.277 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.679 ns/day, 35.355 hours/ns, 7.857 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.74     | 126.74     | 126.74     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099697   | 0.099697   | 0.099697   |   0.0 |  0.08
Output  | 0.00015745 | 0.00015745 | 0.00015745 |   0.0 |  0.00
Modify  | 0.37607    | 0.37607    | 0.37607    |   0.0 |  0.30
Other   |            | 0.06092    |            |       |  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:      128244.0 ave      128244 max      128244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128244
Ave neighs/atom = 64.122000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.666867246819, Press = 1.89937363191162
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8412.3615   -8412.3615   -8495.4987   -8495.4987    321.74937    321.74937    23376.935    23376.935    1529.5758    1529.5758 
   48000   -8416.0664   -8416.0664   -8495.1812   -8495.1812     306.1825     306.1825    23385.309    23385.309    753.72254    753.72254 
Loop time of 125.804 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.687 ns/day, 34.945 hours/ns, 7.949 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.27     | 125.27     | 125.27     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10054    | 0.10054    | 0.10054    |   0.0 |  0.08
Output  | 0.00015467 | 0.00015467 | 0.00015467 |   0.0 |  0.00
Modify  | 0.37038    | 0.37038    | 0.37038    |   0.0 |  0.29
Other   |            | 0.06009    |            |       |  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:      128244.0 ave      128244 max      128244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128244
Ave neighs/atom = 64.122000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.625826440601, Press = 1.60805391302989
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8416.0664   -8416.0664   -8495.1812   -8495.1812     306.1825     306.1825    23385.309    23385.309    753.72254    753.72254 
   49000   -8414.9772   -8414.9772    -8496.301    -8496.301    314.73124    314.73124    23399.805    23399.805   -469.56901   -469.56901 
Loop time of 121.621 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.710 ns/day, 33.784 hours/ns, 8.222 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.11     | 121.11     | 121.11     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097314   | 0.097314   | 0.097314   |   0.0 |  0.08
Output  | 0.00015536 | 0.00015536 | 0.00015536 |   0.0 |  0.00
Modify  | 0.35239    | 0.35239    | 0.35239    |   0.0 |  0.29
Other   |            | 0.05832    |            |       |  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:      128164.0 ave      128164 max      128164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128164
Ave neighs/atom = 64.082000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.614344572142, Press = 1.18796448120744
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8414.9772   -8414.9772    -8496.301    -8496.301    314.73124    314.73124    23399.805    23399.805   -469.56901   -469.56901 
   50000   -8413.4458   -8413.4458   -8494.2045   -8494.2045    312.54432    312.54432    23427.955    23427.955   -2198.2541   -2198.2541 
Loop time of 121.396 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.712 ns/day, 33.721 hours/ns, 8.238 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.89     | 120.89     | 120.89     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096589   | 0.096589   | 0.096589   |   0.0 |  0.08
Output  | 0.00015598 | 0.00015598 | 0.00015598 |   0.0 |  0.00
Modify  | 0.3521     | 0.3521     | 0.3521     |   0.0 |  0.29
Other   |            | 0.05872    |            |       |  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:      128234.0 ave      128234 max      128234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128234
Ave neighs/atom = 64.117000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.538666569599, Press = 0.966537065177624
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8413.4458   -8413.4458   -8494.2045   -8494.2045    312.54432    312.54432    23427.955    23427.955   -2198.2541   -2198.2541 
   51000   -8416.5089   -8416.5089   -8494.7455   -8494.7455    302.78366    302.78366    23448.054    23448.054   -3899.0431   -3899.0431 
Loop time of 122.569 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.705 ns/day, 34.047 hours/ns, 8.159 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.06     | 122.06     | 122.06     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097723   | 0.097723   | 0.097723   |   0.0 |  0.08
Output  | 0.00021889 | 0.00021889 | 0.00021889 |   0.0 |  0.00
Modify  | 0.35461    | 0.35461    | 0.35461    |   0.0 |  0.29
Other   |            | 0.05813    |            |       |  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:      128222.0 ave      128222 max      128222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128222
Ave neighs/atom = 64.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 = 313.48938688615, Press = 2.27019364082533
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8416.5089   -8416.5089   -8494.7455   -8494.7455    302.78366    302.78366    23448.054    23448.054   -3899.0431   -3899.0431 
   52000    -8407.991    -8407.991   -8492.1176   -8492.1176    325.57851    325.57851    23434.849    23434.849   -2181.4923   -2181.4923 
Loop time of 135.49 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.638 ns/day, 37.636 hours/ns, 7.381 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.91     | 134.91     | 134.91     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10516    | 0.10516    | 0.10516    |   0.0 |  0.08
Output  | 0.00021463 | 0.00021463 | 0.00021463 |   0.0 |  0.00
Modify  | 0.40914    | 0.40914    | 0.40914    |   0.0 |  0.30
Other   |            | 0.06384    |            |       |  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:      128200.0 ave      128200 max      128200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128200
Ave neighs/atom = 64.100000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.490756797944, Press = 2.9772889477293
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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    -8407.991    -8407.991   -8492.1176   -8492.1176    325.57851    325.57851    23434.849    23434.849   -2181.4923   -2181.4923 
   53000   -8414.5218   -8414.5218   -8493.4148   -8493.4148    305.32392    305.32392     23404.89     23404.89   -378.57447   -378.57447 
Loop time of 125.987 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.686 ns/day, 34.996 hours/ns, 7.937 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.46     | 125.46     | 125.46     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09934    | 0.09934    | 0.09934    |   0.0 |  0.08
Output  | 0.00019047 | 0.00019047 | 0.00019047 |   0.0 |  0.00
Modify  | 0.36892    | 0.36892    | 0.36892    |   0.0 |  0.29
Other   |            | 0.0597     |            |       |  0.05

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

Total # of neighbors = 128250
Ave neighs/atom = 64.125000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.504755277926, Press = 2.94202355826101
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8414.5218   -8414.5218   -8493.4148   -8493.4148    305.32392    305.32392     23404.89     23404.89   -378.57447   -378.57447 
   54000   -8409.1191   -8409.1191   -8490.4147   -8490.4147    314.62241    314.62241    23393.889    23393.889    911.69732    911.69732 
Loop time of 130.88 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.660 ns/day, 36.356 hours/ns, 7.641 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.32     | 130.32     | 130.32     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10406    | 0.10406    | 0.10406    |   0.0 |  0.08
Output  | 0.00021704 | 0.00021704 | 0.00021704 |   0.0 |  0.00
Modify  | 0.39542    | 0.39542    | 0.39542    |   0.0 |  0.30
Other   |            | 0.06145    |            |       |  0.05

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

Total # of neighbors = 128240
Ave neighs/atom = 64.120000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.544745256605, Press = 2.97183742570159
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8409.1191   -8409.1191   -8490.4147   -8490.4147    314.62241    314.62241    23393.889    23393.889    911.69732    911.69732 
   55000   -8413.8281   -8413.8281   -8497.1011   -8497.1011    322.27509    322.27509     23370.25     23370.25    1772.4627    1772.4627 
Loop time of 126.15 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.685 ns/day, 35.042 hours/ns, 7.927 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.62     | 125.62     | 125.62     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10104    | 0.10104    | 0.10104    |   0.0 |  0.08
Output  | 0.00015882 | 0.00015882 | 0.00015882 |   0.0 |  0.00
Modify  | 0.37196    | 0.37196    | 0.37196    |   0.0 |  0.29
Other   |            | 0.06033    |            |       |  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:      128262.0 ave      128262 max      128262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128262
Ave neighs/atom = 64.131000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.55502116481, Press = 2.59945294646592
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8413.8281   -8413.8281   -8497.1011   -8497.1011    322.27509    322.27509     23370.25     23370.25    1772.4627    1772.4627 
   56000   -8417.4175   -8417.4175   -8495.8274   -8495.8274    303.45423    303.45423    23359.022    23359.022    2541.5606    2541.5606 
Loop time of 121.536 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.760 hours/ns, 8.228 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.03     | 121.03     | 121.03     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096036   | 0.096036   | 0.096036   |   0.0 |  0.08
Output  | 0.00015855 | 0.00015855 | 0.00015855 |   0.0 |  0.00
Modify  | 0.3511     | 0.3511     | 0.3511     |   0.0 |  0.29
Other   |            | 0.05866    |            |       |  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:      128228.0 ave      128228 max      128228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128228
Ave neighs/atom = 64.114000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.542227286576, Press = 1.27306921764682
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8417.4175   -8417.4175   -8495.8274   -8495.8274    303.45423    303.45423    23359.022    23359.022    2541.5606    2541.5606 
   57000   -8414.0591   -8414.0591   -8494.8557   -8494.8557    312.69122    312.69122    23383.567    23383.567    907.91108    907.91108 
Loop time of 135.899 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.636 ns/day, 37.750 hours/ns, 7.358 timesteps/s
99.9% 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.32     | 135.32     | 135.32     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10597    | 0.10597    | 0.10597    |   0.0 |  0.08
Output  | 0.00019738 | 0.00019738 | 0.00019738 |   0.0 |  0.00
Modify  | 0.41343    | 0.41343    | 0.41343    |   0.0 |  0.30
Other   |            | 0.06287    |            |       |  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:      128208.0 ave      128208 max      128208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128208
Ave neighs/atom = 64.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 = 313.534711540975, Press = 0.547311882102407
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8414.0591   -8414.0591   -8494.8557   -8494.8557    312.69122    312.69122    23383.567    23383.567    907.91108    907.91108 
   58000   -8416.4453   -8416.4453   -8497.5091   -8497.5091    313.72562    313.72562    23411.959    23411.959   -1497.8081   -1497.8081 
Loop time of 122.807 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.704 ns/day, 34.113 hours/ns, 8.143 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.29     | 122.29     | 122.29     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097623   | 0.097623   | 0.097623   |   0.0 |  0.08
Output  | 0.00015344 | 0.00015344 | 0.00015344 |   0.0 |  0.00
Modify  | 0.35811    | 0.35811    | 0.35811    |   0.0 |  0.29
Other   |            | 0.05859    |            |       |  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:      128242.0 ave      128242 max      128242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128242
Ave neighs/atom = 64.121000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.512489557679, Press = 0.342213991827194
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8416.4453   -8416.4453   -8497.5091   -8497.5091    313.72562    313.72562    23411.959    23411.959   -1497.8081   -1497.8081 
   59000   -8412.5559   -8412.5559   -8493.4268   -8493.4268    312.97871    312.97871    23428.729    23428.729   -1950.7866   -1950.7866 
Loop time of 121.31 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.712 ns/day, 33.697 hours/ns, 8.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    | 120.8      | 120.8      | 120.8      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0975     | 0.0975     | 0.0975     |   0.0 |  0.08
Output  | 0.00015398 | 0.00015398 | 0.00015398 |   0.0 |  0.00
Modify  | 0.35357    | 0.35357    | 0.35357    |   0.0 |  0.29
Other   |            | 0.05828    |            |       |  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:      128192.0 ave      128192 max      128192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128192
Ave neighs/atom = 64.096000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.459166857278, Press = 1.12007702942668
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8412.5559   -8412.5559   -8493.4268   -8493.4268    312.97871    312.97871    23428.729    23428.729   -1950.7866   -1950.7866 
   60000   -8414.8918   -8414.8918   -8495.3509   -8495.3509    311.38533    311.38533    23410.072    23410.072   -1042.2136   -1042.2136 
Loop time of 121.563 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.768 hours/ns, 8.226 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.05     | 121.05     | 121.05     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097403   | 0.097403   | 0.097403   |   0.0 |  0.08
Output  | 0.0001572  | 0.0001572  | 0.0001572  |   0.0 |  0.00
Modify  | 0.35314    | 0.35314    | 0.35314    |   0.0 |  0.29
Other   |            | 0.05831    |            |       |  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:      128182.0 ave      128182 max      128182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128182
Ave neighs/atom = 64.091000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.438809504793, Press = 2.09382426070024
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8414.8918   -8414.8918   -8495.3509   -8495.3509    311.38533    311.38533    23410.072    23410.072   -1042.2136   -1042.2136 
   61000    -8411.953    -8411.953   -8494.4637   -8494.4637    319.32507    319.32507    23395.676    23395.676    304.08017    304.08017 
Loop time of 128.275 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.674 ns/day, 35.632 hours/ns, 7.796 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.73     | 127.73     | 127.73     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10114    | 0.10114    | 0.10114    |   0.0 |  0.08
Output  | 0.00015505 | 0.00015505 | 0.00015505 |   0.0 |  0.00
Modify  | 0.38066    | 0.38066    | 0.38066    |   0.0 |  0.30
Other   |            | 0.06072    |            |       |  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:      128244.0 ave      128244 max      128244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128244
Ave neighs/atom = 64.122000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.430931922255, Press = 2.45541729883465
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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    -8411.953    -8411.953   -8494.4637   -8494.4637    319.32507    319.32507    23395.676    23395.676    304.08017    304.08017 
   62000   -8415.8206   -8415.8206    -8497.148    -8497.148    314.74519    314.74519    23371.347    23371.347    1618.8089    1618.8089 
Loop time of 131.243 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.658 ns/day, 36.456 hours/ns, 7.619 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.68     | 130.68     | 130.68     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10339    | 0.10339    | 0.10339    |   0.0 |  0.08
Output  | 0.0001543  | 0.0001543  | 0.0001543  |   0.0 |  0.00
Modify  | 0.39569    | 0.39569    | 0.39569    |   0.0 |  0.30
Other   |            | 0.06175    |            |       |  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:      128228.0 ave      128228 max      128228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128228
Ave neighs/atom = 64.114000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.383717365542, Press = 2.28972723775062
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8415.8206   -8415.8206    -8497.148    -8497.148    314.74519    314.74519    23371.347    23371.347    1618.8089    1618.8089 
   63000   -8413.7154   -8413.7154    -8494.637    -8494.637    313.17473    313.17473    23375.712    23375.712    1682.0384    1682.0384 
Loop time of 139.651 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.619 ns/day, 38.792 hours/ns, 7.161 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.05     | 139.05     | 139.05     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10928    | 0.10928    | 0.10928    |   0.0 |  0.08
Output  | 0.00015492 | 0.00015492 | 0.00015492 |   0.0 |  0.00
Modify  | 0.42867    | 0.42867    | 0.42867    |   0.0 |  0.31
Other   |            | 0.06503    |            |       |  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:      128234.0 ave      128234 max      128234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128234
Ave neighs/atom = 64.117000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.356845283145, Press = 1.03632605280675
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8413.7154   -8413.7154    -8494.637    -8494.637    313.17473    313.17473    23375.712    23375.712    1682.0384    1682.0384 
   64000    -8416.284    -8416.284   -8496.2554   -8496.2554    309.49758    309.49758    23392.824    23392.824    97.512761    97.512761 
Loop time of 131.713 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.656 ns/day, 36.587 hours/ns, 7.592 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.15     | 131.15     | 131.15     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10359    | 0.10359    | 0.10359    |   0.0 |  0.08
Output  | 0.00019715 | 0.00019715 | 0.00019715 |   0.0 |  0.00
Modify  | 0.39327    | 0.39327    | 0.39327    |   0.0 |  0.30
Other   |            | 0.06253    |            |       |  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:      128242.0 ave      128242 max      128242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128242
Ave neighs/atom = 64.121000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.311806400938, Press = -0.213234454822392
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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    -8416.284    -8416.284   -8496.2554   -8496.2554    309.49758    309.49758    23392.824    23392.824    97.512761    97.512761 
   65000   -8415.1944   -8415.1944   -8493.7576   -8493.7576    304.04752    304.04752    23423.297    23423.297   -1772.8985   -1772.8985 
Loop time of 142.812 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.605 ns/day, 39.670 hours/ns, 7.002 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    | 142.19     | 142.19     | 142.19     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.11106    | 0.11106    | 0.11106    |   0.0 |  0.08
Output  | 0.00015884 | 0.00015884 | 0.00015884 |   0.0 |  0.00
Modify  | 0.43971    | 0.43971    | 0.43971    |   0.0 |  0.31
Other   |            | 0.06626    |            |       |  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:      128204.0 ave      128204 max      128204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128204
Ave neighs/atom = 64.102000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.340830127941, Press = 0.539899182221548
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8415.1944   -8415.1944   -8493.7576   -8493.7576    304.04752    304.04752    23423.297    23423.297   -1772.8985   -1772.8985 
   66000   -8411.4299   -8411.4299   -8492.5583   -8492.5583    313.97504    313.97504    23432.594    23432.594   -2133.5889   -2133.5889 
Loop time of 125.4 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.689 ns/day, 34.833 hours/ns, 7.974 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.87     | 124.87     | 124.87     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098822   | 0.098822   | 0.098822   |   0.0 |  0.08
Output  | 0.00021604 | 0.00021604 | 0.00021604 |   0.0 |  0.00
Modify  | 0.36706    | 0.36706    | 0.36706    |   0.0 |  0.29
Other   |            | 0.06       |            |       |  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:      128228.0 ave      128228 max      128228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128228
Ave neighs/atom = 64.114000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.358627691415, Press = 1.65422991611536
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8411.4299   -8411.4299   -8492.5583   -8492.5583    313.97504    313.97504    23432.594    23432.594   -2133.5889   -2133.5889 
   67000   -8412.7498   -8412.7498   -8494.3483   -8494.3483    315.79463    315.79463    23419.856    23419.856   -1608.2766   -1608.2766 
Loop time of 141.955 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.609 ns/day, 39.432 hours/ns, 7.044 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    | 141.34     | 141.34     | 141.34     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1089     | 0.1089     | 0.1089     |   0.0 |  0.08
Output  | 0.00020958 | 0.00020958 | 0.00020958 |   0.0 |  0.00
Modify  | 0.43632    | 0.43632    | 0.43632    |   0.0 |  0.31
Other   |            | 0.06506    |            |       |  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:      128218.0 ave      128218 max      128218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128218
Ave neighs/atom = 64.109000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.406509221926, Press = 2.11179110333031
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8412.7498   -8412.7498   -8494.3483   -8494.3483    315.79463    315.79463    23419.856    23419.856   -1608.2766   -1608.2766 
   68000   -8413.3732   -8413.3732   -8494.1588   -8494.1588    312.64885    312.64885    23407.183    23407.183   -574.42524   -574.42524 
Loop time of 124.534 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.694 ns/day, 34.593 hours/ns, 8.030 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.01     | 124.01     | 124.01     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0989     | 0.0989     | 0.0989     |   0.0 |  0.08
Output  | 0.00015726 | 0.00015726 | 0.00015726 |   0.0 |  0.00
Modify  | 0.36698    | 0.36698    | 0.36698    |   0.0 |  0.29
Other   |            | 0.05979    |            |       |  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:      128256.0 ave      128256 max      128256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128256
Ave neighs/atom = 64.128000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.405130058995, Press = 2.08269673494617
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8413.3732   -8413.3732   -8494.1588   -8494.1588    312.64885    312.64885    23407.183    23407.183   -574.42524   -574.42524 
   69000   -8414.3139   -8414.3139   -8494.7175   -8494.7175     311.1703     311.1703     23403.98     23403.98   -425.81902   -425.81902 
Loop time of 139.358 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.620 ns/day, 38.710 hours/ns, 7.176 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.76     | 138.76     | 138.76     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10832    | 0.10832    | 0.10832    |   0.0 |  0.08
Output  | 0.00015556 | 0.00015556 | 0.00015556 |   0.0 |  0.00
Modify  | 0.4249     | 0.4249     | 0.4249     |   0.0 |  0.30
Other   |            | 0.06437    |            |       |  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:      128234.0 ave      128234 max      128234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128234
Ave neighs/atom = 64.117000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.43231455052, Press = 1.77505099781458
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8414.3139   -8414.3139   -8494.7175   -8494.7175     311.1703     311.1703     23403.98     23403.98   -425.81902   -425.81902 
   70000   -8409.0911   -8409.0911   -8492.1822   -8492.1822    321.57138    321.57138    23409.986    23409.986    -390.2902    -390.2902 
Loop time of 122.074 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.708 ns/day, 33.909 hours/ns, 8.192 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.56     | 121.56     | 121.56     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096884   | 0.096884   | 0.096884   |   0.0 |  0.08
Output  | 0.00020657 | 0.00020657 | 0.00020657 |   0.0 |  0.00
Modify  | 0.35343    | 0.35343    | 0.35343    |   0.0 |  0.29
Other   |            | 0.05944    |            |       |  0.05

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

Total # of neighbors = 128236
Ave neighs/atom = 64.118000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.446625971, Press = 1.48706018527834
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8409.0911   -8409.0911   -8492.1822   -8492.1822    321.57138    321.57138    23409.986    23409.986    -390.2902    -390.2902 
   71000   -8412.9287   -8412.9287   -8494.4581   -8494.4581    315.52709    315.52709    23411.286    23411.286   -964.57191   -964.57191 
Loop time of 125.392 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.689 ns/day, 34.831 hours/ns, 7.975 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.87     | 124.87     | 124.87     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098818   | 0.098818   | 0.098818   |   0.0 |  0.08
Output  | 0.00047354 | 0.00047354 | 0.00047354 |   0.0 |  0.00
Modify  | 0.36534    | 0.36534    | 0.36534    |   0.0 |  0.29
Other   |            | 0.0592     |            |       |  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:      128250.0 ave      128250 max      128250 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128250
Ave neighs/atom = 64.125000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.456717837891, Press = 1.34126781996613
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8412.9287   -8412.9287   -8494.4581   -8494.4581    315.52709    315.52709    23411.286    23411.286   -964.57191   -964.57191 
   72000   -8413.0146   -8413.0146   -8495.7482   -8495.7482    320.18736    320.18736    23405.765    23405.765   -767.68418   -767.68418 
Loop time of 122.602 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.705 ns/day, 34.056 hours/ns, 8.156 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.09     | 122.09     | 122.09     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098047   | 0.098047   | 0.098047   |   0.0 |  0.08
Output  | 0.00019197 | 0.00019197 | 0.00019197 |   0.0 |  0.00
Modify  | 0.35728    | 0.35728    | 0.35728    |   0.0 |  0.29
Other   |            | 0.05888    |            |       |  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:      128220.0 ave      128220 max      128220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128220
Ave neighs/atom = 64.110000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.420526422896, Press = 1.83264203733806
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8413.0146   -8413.0146   -8495.7482   -8495.7482    320.18736    320.18736    23405.765    23405.765   -767.68418   -767.68418 
   73000   -8413.2655   -8413.2655    -8494.485    -8494.485    314.32759    314.32759    23377.542    23377.542    1564.7257    1564.7257 
Loop time of 121.654 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.710 ns/day, 33.793 hours/ns, 8.220 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.15     | 121.15     | 121.15     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096943   | 0.096943   | 0.096943   |   0.0 |  0.08
Output  | 0.00019051 | 0.00019051 | 0.00019051 |   0.0 |  0.00
Modify  | 0.35028    | 0.35028    | 0.35028    |   0.0 |  0.29
Other   |            | 0.05893    |            |       |  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:      128254.0 ave      128254 max      128254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128254
Ave neighs/atom = 64.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 = 313.391897104987, Press = 2.01204675552809
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8413.2655   -8413.2655    -8494.485    -8494.485    314.32759    314.32759    23377.542    23377.542    1564.7257    1564.7257 
   74000   -8414.4813   -8414.4813   -8492.5573   -8492.5573    302.16203    302.16203    23356.165    23356.165    3173.6846    3173.6846 
Loop time of 121.564 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.768 hours/ns, 8.226 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.06     | 121.06     | 121.06     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096771   | 0.096771   | 0.096771   |   0.0 |  0.08
Output  | 0.00015677 | 0.00015677 | 0.00015677 |   0.0 |  0.00
Modify  | 0.3519     | 0.3519     | 0.3519     |   0.0 |  0.29
Other   |            | 0.05906    |            |       |  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:      128248.0 ave      128248 max      128248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128248
Ave neighs/atom = 64.124000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.351739103807, Press = 1.64538725457926
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8414.4813   -8414.4813   -8492.5573   -8492.5573    302.16203    302.16203    23356.165    23356.165    3173.6846    3173.6846 
   75000   -8413.7701   -8413.7701   -8496.5426   -8496.5426    320.33826    320.33826    23366.326    23366.326      2072.54      2072.54 
Loop time of 121.568 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.769 hours/ns, 8.226 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.06     | 121.06     | 121.06     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097918   | 0.097918   | 0.097918   |   0.0 |  0.08
Output  | 0.0001568  | 0.0001568  | 0.0001568  |   0.0 |  0.00
Modify  | 0.352      | 0.352      | 0.352      |   0.0 |  0.29
Other   |            | 0.0589     |            |       |  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:      128280.0 ave      128280 max      128280 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128280
Ave neighs/atom = 64.140000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.326985881304, Press = 0.936139683858397
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8413.7701   -8413.7701   -8496.5426   -8496.5426    320.33826    320.33826    23366.326    23366.326      2072.54      2072.54 
   76000   -8409.1468   -8409.1468   -8490.2762   -8490.2762    313.97931    313.97931    23400.153    23400.153    541.74058    541.74058 
Loop time of 131.351 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.658 ns/day, 36.486 hours/ns, 7.613 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.79     | 130.79     | 130.79     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10324    | 0.10324    | 0.10324    |   0.0 |  0.08
Output  | 0.00015323 | 0.00015323 | 0.00015323 |   0.0 |  0.00
Modify  | 0.39313    | 0.39313    | 0.39313    |   0.0 |  0.30
Other   |            | 0.06196    |            |       |  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:      128222.0 ave      128222 max      128222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128222
Ave neighs/atom = 64.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 = 313.326316631047, Press = 0.811981279063767
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8409.1468   -8409.1468   -8490.2762   -8490.2762    313.97931    313.97931    23400.153    23400.153    541.74058    541.74058 
   77000   -8414.5142   -8414.5142   -8494.4787   -8494.4787    309.47107    309.47107    23391.197    23391.197    436.79627    436.79627 
Loop time of 121.804 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.709 ns/day, 33.834 hours/ns, 8.210 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.3      | 121.3      | 121.3      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096241   | 0.096241   | 0.096241   |   0.0 |  0.08
Output  | 0.00015605 | 0.00015605 | 0.00015605 |   0.0 |  0.00
Modify  | 0.35276    | 0.35276    | 0.35276    |   0.0 |  0.29
Other   |            | 0.05837    |            |       |  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:      128230.0 ave      128230 max      128230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128230
Ave neighs/atom = 64.115000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.345274183102, Press = 1.1291168753324
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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   -8414.5142   -8414.5142   -8494.4787   -8494.4787    309.47107    309.47107    23391.197    23391.197    436.79627    436.79627 
   78000   -8407.8249   -8407.8249   -8491.7213   -8491.7213    324.68755    324.68755    23414.358    23414.358   -628.37383   -628.37383 
Loop time of 121.119 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.644 hours/ns, 8.256 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.61     | 120.61     | 120.61     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096999   | 0.096999   | 0.096999   |   0.0 |  0.08
Output  | 0.00015524 | 0.00015524 | 0.00015524 |   0.0 |  0.00
Modify  | 0.35238    | 0.35238    | 0.35238    |   0.0 |  0.29
Other   |            | 0.05791    |            |       |  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:      128244.0 ave      128244 max      128244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128244
Ave neighs/atom = 64.122000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.377526605502, Press = 1.04941739544031
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   78000   -8407.8249   -8407.8249   -8491.7213   -8491.7213    324.68755    324.68755    23414.358    23414.358   -628.37383   -628.37383 
   79000   -8415.1272   -8415.1272   -8495.1277   -8495.1277    309.60992    309.60992    23418.984    23418.984   -1762.2443   -1762.2443 
Loop time of 121.582 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.773 hours/ns, 8.225 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.08     | 121.08     | 121.08     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096732   | 0.096732   | 0.096732   |   0.0 |  0.08
Output  | 0.00015046 | 0.00015046 | 0.00015046 |   0.0 |  0.00
Modify  | 0.35161    | 0.35161    | 0.35161    |   0.0 |  0.29
Other   |            | 0.05774    |            |       |  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:      128272.0 ave      128272 max      128272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128272
Ave neighs/atom = 64.136000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.393885978834, Press = 0.858106797629943
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   79000   -8415.1272   -8415.1272   -8495.1277   -8495.1277    309.60992    309.60992    23418.984    23418.984   -1762.2443   -1762.2443 
   80000   -8413.5463   -8413.5463   -8493.9195   -8493.9195     311.0525     311.0525    23439.553    23439.553   -2896.3574   -2896.3574 
Loop time of 121.199 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.666 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.69     | 120.69     | 120.69     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095834   | 0.095834   | 0.095834   |   0.0 |  0.08
Output  | 0.00015689 | 0.00015689 | 0.00015689 |   0.0 |  0.00
Modify  | 0.35148    | 0.35148    | 0.35148    |   0.0 |  0.29
Other   |            | 0.05795    |            |       |  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:      128224.0 ave      128224 max      128224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128224
Ave neighs/atom = 64.112000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.409062148937, Press = 1.45723297136905
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   80000   -8413.5463   -8413.5463   -8493.9195   -8493.9195     311.0525     311.0525    23439.553    23439.553   -2896.3574   -2896.3574 
   81000   -8409.5575   -8409.5575   -8491.2695   -8491.2695    316.23383    316.23383    23423.615    23423.615   -1313.3771   -1313.3771 
Loop time of 126.021 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.686 ns/day, 35.006 hours/ns, 7.935 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.49     | 125.49     | 125.49     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098166   | 0.098166   | 0.098166   |   0.0 |  0.08
Output  | 0.00015576 | 0.00015576 | 0.00015576 |   0.0 |  0.00
Modify  | 0.37412    | 0.37412    | 0.37412    |   0.0 |  0.30
Other   |            | 0.06004    |            |       |  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:      128204.0 ave      128204 max      128204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128204
Ave neighs/atom = 64.102000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.425075643941, Press = 1.97649238481826
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   81000   -8409.5575   -8409.5575   -8491.2695   -8491.2695    316.23383    316.23383    23423.615    23423.615   -1313.3771   -1313.3771 
   82000   -8414.7389   -8414.7389   -8494.9733   -8494.9733    310.51543    310.51543    23379.074    23379.074    1213.0544    1213.0544 
Loop time of 132.102 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.654 ns/day, 36.695 hours/ns, 7.570 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.54     | 131.54     | 131.54     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10228    | 0.10228    | 0.10228    |   0.0 |  0.08
Output  | 0.00015427 | 0.00015427 | 0.00015427 |   0.0 |  0.00
Modify  | 0.39822    | 0.39822    | 0.39822    |   0.0 |  0.30
Other   |            | 0.06188    |            |       |  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:      128254.0 ave      128254 max      128254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128254
Ave neighs/atom = 64.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 = 313.454577036687, Press = 1.8482670635441
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   82000   -8414.7389   -8414.7389   -8494.9733   -8494.9733    310.51543    310.51543    23379.074    23379.074    1213.0544    1213.0544 
   83000   -8408.7887   -8408.7887   -8491.5564   -8491.5564    320.31949    320.31949    23390.814    23390.814    1121.9137    1121.9137 
Loop time of 133.133 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.649 ns/day, 36.982 hours/ns, 7.511 timesteps/s
99.9% 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.57     | 132.57     | 132.57     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10232    | 0.10232    | 0.10232    |   0.0 |  0.08
Output  | 0.00015528 | 0.00015528 | 0.00015528 |   0.0 |  0.00
Modify  | 0.39937    | 0.39937    | 0.39937    |   0.0 |  0.30
Other   |            | 0.06229    |            |       |  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:      128222.0 ave      128222 max      128222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128222
Ave neighs/atom = 64.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 = 313.469885024905, Press = 1.21249268918674
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   83000   -8408.7887   -8408.7887   -8491.5564   -8491.5564    320.31949    320.31949    23390.814    23390.814    1121.9137    1121.9137 
   84000   -8414.0565   -8414.0565   -8494.7998   -8494.7998    312.48486    312.48486     23387.95     23387.95    639.94095    639.94095 
Loop time of 121.439 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.733 hours/ns, 8.235 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.93     | 120.93     | 120.93     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09471    | 0.09471    | 0.09471    |   0.0 |  0.08
Output  | 0.00015597 | 0.00015597 | 0.00015597 |   0.0 |  0.00
Modify  | 0.35129    | 0.35129    | 0.35129    |   0.0 |  0.29
Other   |            | 0.0583     |            |       |  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:      128240.0 ave      128240 max      128240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128240
Ave neighs/atom = 64.120000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.464393754984, Press = 0.916927032224729
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   84000   -8414.0565   -8414.0565   -8494.7998   -8494.7998    312.48486    312.48486     23387.95     23387.95    639.94095    639.94095 
   85000   -8413.5547   -8413.5547   -8493.9372   -8493.9372    311.08865    311.08865    23390.671    23390.671    477.91644    477.91644 
Loop time of 121.036 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.621 hours/ns, 8.262 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.53     | 120.53     | 120.53     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094254   | 0.094254   | 0.094254   |   0.0 |  0.08
Output  | 0.00015947 | 0.00015947 | 0.00015947 |   0.0 |  0.00
Modify  | 0.34907    | 0.34907    | 0.34907    |   0.0 |  0.29
Other   |            | 0.05797    |            |       |  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:      128256.0 ave      128256 max      128256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128256
Ave neighs/atom = 64.128000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.443787018211, Press = 1.1298975757419
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   85000   -8413.5547   -8413.5547   -8493.9372   -8493.9372    311.08865    311.08865    23390.671    23390.671    477.91644    477.91644 
   86000   -8414.2902   -8414.2902   -8494.2355   -8494.2355    309.39648    309.39648    23379.297    23379.297    1213.3822    1213.3822 
Loop time of 123.515 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.700 ns/day, 34.310 hours/ns, 8.096 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    | 123        | 123        | 123        |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095597   | 0.095597   | 0.095597   |   0.0 |  0.08
Output  | 0.0001993  | 0.0001993  | 0.0001993  |   0.0 |  0.00
Modify  | 0.35983    | 0.35983    | 0.35983    |   0.0 |  0.29
Other   |            | 0.0589     |            |       |  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:      128232.0 ave      128232 max      128232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128232
Ave neighs/atom = 64.116000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.40512811145, Press = 0.948780405771357
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   86000   -8414.2902   -8414.2902   -8494.2355   -8494.2355    309.39648    309.39648    23379.297    23379.297    1213.3822    1213.3822 
   87000   -8417.6388   -8417.6388   -8497.3964   -8497.3964     308.6702     308.6702    23375.493    23375.493    1020.7746    1020.7746 
Loop time of 141.955 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.609 ns/day, 39.432 hours/ns, 7.044 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    | 141.34     | 141.34     | 141.34     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10833    | 0.10833    | 0.10833    |   0.0 |  0.08
Output  | 0.00015676 | 0.00015676 | 0.00015676 |   0.0 |  0.00
Modify  | 0.43949    | 0.43949    | 0.43949    |   0.0 |  0.31
Other   |            | 0.06593    |            |       |  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:      128330.0 ave      128330 max      128330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128330
Ave neighs/atom = 64.165000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.392789252204, Press = 0.251459704707807
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   87000   -8417.6388   -8417.6388   -8497.3964   -8497.3964     308.6702     308.6702    23375.493    23375.493    1020.7746    1020.7746 
   88000   -8413.9406   -8413.9406   -8495.8717   -8495.8717    317.08197    317.08197    23414.001    23414.001   -1454.1974   -1454.1974 
Loop time of 132.75 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.651 ns/day, 36.875 hours/ns, 7.533 timesteps/s
99.9% 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.19     | 132.19     | 132.19     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10265    | 0.10265    | 0.10265    |   0.0 |  0.08
Output  | 0.00019329 | 0.00019329 | 0.00019329 |   0.0 |  0.00
Modify  | 0.39962    | 0.39962    | 0.39962    |   0.0 |  0.30
Other   |            | 0.06234    |            |       |  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:      128222.0 ave      128222 max      128222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128222
Ave neighs/atom = 64.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 = 313.353857835721, Press = -0.0308060903280957
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   88000   -8413.9406   -8413.9406   -8495.8717   -8495.8717    317.08197    317.08197    23414.001    23414.001   -1454.1974   -1454.1974 
   89000   -8414.1673   -8414.1673   -8493.9762   -8493.9762    308.86859    308.86859    23430.941    23430.941   -2380.2058   -2380.2058 
Loop time of 123.798 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.698 ns/day, 34.388 hours/ns, 8.078 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    | 123.28     | 123.28     | 123.28     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097229   | 0.097229   | 0.097229   |   0.0 |  0.08
Output  | 0.00015543 | 0.00015543 | 0.00015543 |   0.0 |  0.00
Modify  | 0.36164    | 0.36164    | 0.36164    |   0.0 |  0.29
Other   |            | 0.05964    |            |       |  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:      128194.0 ave      128194 max      128194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128194
Ave neighs/atom = 64.097000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.358277072104, Press = 0.330352899636354
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   89000   -8414.1673   -8414.1673   -8493.9762   -8493.9762    308.86859    308.86859    23430.941    23430.941   -2380.2058   -2380.2058 
   90000   -8415.3385   -8415.3385   -8495.8138   -8495.8138    311.44742    311.44742    23416.788    23416.788   -1599.0691   -1599.0691 
Loop time of 121.165 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.657 hours/ns, 8.253 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.66     | 120.66     | 120.66     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09525    | 0.09525    | 0.09525    |   0.0 |  0.08
Output  | 0.00015686 | 0.00015686 | 0.00015686 |   0.0 |  0.00
Modify  | 0.35035    | 0.35035    | 0.35035    |   0.0 |  0.29
Other   |            | 0.05893    |            |       |  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:      128206.0 ave      128206 max      128206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128206
Ave neighs/atom = 64.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 = 313.377150235693, Press = 0.849350052081561
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   90000   -8415.3385   -8415.3385   -8495.8138   -8495.8138    311.44742    311.44742    23416.788    23416.788   -1599.0691   -1599.0691 
   91000   -8415.4879   -8415.4879   -8494.8597   -8494.8597    307.17719    307.17719    23407.028    23407.028    -930.4888    -930.4888 
Loop time of 125.639 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.688 ns/day, 34.900 hours/ns, 7.959 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.11     | 125.11     | 125.11     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097744   | 0.097744   | 0.097744   |   0.0 |  0.08
Output  | 0.00015796 | 0.00015796 | 0.00015796 |   0.0 |  0.00
Modify  | 0.37036    | 0.37036    | 0.37036    |   0.0 |  0.29
Other   |            | 0.0614     |            |       |  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:      128234.0 ave      128234 max      128234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128234
Ave neighs/atom = 64.117000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.379696608743, Press = 1.14275243433938
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   91000   -8415.4879   -8415.4879   -8494.8597   -8494.8597    307.17719    307.17719    23407.028    23407.028    -930.4888    -930.4888 
   92000   -8413.2904   -8413.2904   -8493.9531   -8493.9531    312.17319    312.17319    23401.224    23401.224   -178.78479   -178.78479 
Loop time of 121.954 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.708 ns/day, 33.876 hours/ns, 8.200 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.44     | 121.44     | 121.44     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099107   | 0.099107   | 0.099107   |   0.0 |  0.08
Output  | 0.00016242 | 0.00016242 | 0.00016242 |   0.0 |  0.00
Modify  | 0.35582    | 0.35582    | 0.35582    |   0.0 |  0.29
Other   |            | 0.05898    |            |       |  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:      128236.0 ave      128236 max      128236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128236
Ave neighs/atom = 64.118000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.373368304486, Press = 1.36159516928419
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   92000   -8413.2904   -8413.2904   -8493.9531   -8493.9531    312.17319    312.17319    23401.224    23401.224   -178.78479   -178.78479 
   93000   -8418.2962   -8418.2962   -8498.5876   -8498.5876    310.73586    310.73586    23350.805    23350.805    2695.7243    2695.7243 
Loop time of 132.918 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.650 ns/day, 36.922 hours/ns, 7.523 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.35     | 132.35     | 132.35     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10278    | 0.10278    | 0.10278    |   0.0 |  0.08
Output  | 0.0001584  | 0.0001584  | 0.0001584  |   0.0 |  0.00
Modify  | 0.40201    | 0.40201    | 0.40201    |   0.0 |  0.30
Other   |            | 0.06312    |            |       |  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:      128260.0 ave      128260 max      128260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128260
Ave neighs/atom = 64.130000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.38160013655, Press = 1.74883333057254
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   93000   -8418.2962   -8418.2962   -8498.5876   -8498.5876    310.73586    310.73586    23350.805    23350.805    2695.7243    2695.7243 
   94000   -8413.0711   -8413.0711    -8494.506    -8494.506     315.1614     315.1614    23336.036    23336.036    4515.3073    4515.3073 
Loop time of 130.278 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.663 ns/day, 36.188 hours/ns, 7.676 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129.73     | 129.73     | 129.73     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10163    | 0.10163    | 0.10163    |   0.0 |  0.08
Output  | 0.00015532 | 0.00015532 | 0.00015532 |   0.0 |  0.00
Modify  | 0.38936    | 0.38936    | 0.38936    |   0.0 |  0.30
Other   |            | 0.06151    |            |       |  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:      128240.0 ave      128240 max      128240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128240
Ave neighs/atom = 64.120000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.358884176942, Press = 0.908372818318053
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   94000   -8413.0711   -8413.0711    -8494.506    -8494.506     315.1614     315.1614    23336.036    23336.036    4515.3073    4515.3073 
   95000   -8413.5279   -8413.5279   -8493.1163   -8493.1163    308.01525    308.01525     23375.29     23375.29    1820.8848    1820.8848 
Loop time of 121.136 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.649 hours/ns, 8.255 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.63     | 120.63     | 120.63     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095314   | 0.095314   | 0.095314   |   0.0 |  0.08
Output  | 0.00020301 | 0.00020301 | 0.00020301 |   0.0 |  0.00
Modify  | 0.35096    | 0.35096    | 0.35096    |   0.0 |  0.29
Other   |            | 0.05773    |            |       |  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:      128316.0 ave      128316 max      128316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128316
Ave neighs/atom = 64.158000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.385024877209, Press = 0.414090721379421
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   95000   -8413.5279   -8413.5279   -8493.1163   -8493.1163    308.01525    308.01525     23375.29     23375.29    1820.8848    1820.8848 
   96000   -8418.6544   -8418.6544    -8495.751    -8495.751    298.37183    298.37183    23396.209    23396.209   -338.78874   -338.78874 
Loop time of 136.081 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.635 ns/day, 37.800 hours/ns, 7.349 timesteps/s
99.9% 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.5      | 135.5      | 135.5      |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10522    | 0.10522    | 0.10522    |   0.0 |  0.08
Output  | 0.0001556  | 0.0001556  | 0.0001556  |   0.0 |  0.00
Modify  | 0.41517    | 0.41517    | 0.41517    |   0.0 |  0.31
Other   |            | 0.06404    |            |       |  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:      128268.0 ave      128268 max      128268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128268
Ave neighs/atom = 64.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 = 313.366782196476, Press = 0.516769091266713
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   96000   -8418.6544   -8418.6544    -8495.751    -8495.751    298.37183    298.37183    23396.209    23396.209   -338.78874   -338.78874 
   97000   -8413.3733   -8413.3733   -8494.9038   -8494.9038     315.5312     315.5312    23416.567    23416.567   -1438.8229   -1438.8229 
Loop time of 135.473 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.638 ns/day, 37.631 hours/ns, 7.382 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.89     | 134.89     | 134.89     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10421    | 0.10421    | 0.10421    |   0.0 |  0.08
Output  | 0.00015167 | 0.00015167 | 0.00015167 |   0.0 |  0.00
Modify  | 0.41251    | 0.41251    | 0.41251    |   0.0 |  0.30
Other   |            | 0.0639     |            |       |  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:      128232.0 ave      128232 max      128232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128232
Ave neighs/atom = 64.116000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.361244659681, Press = 0.808098377960825
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   97000   -8413.3733   -8413.3733   -8494.9038   -8494.9038     315.5312     315.5312    23416.567    23416.567   -1438.8229   -1438.8229 
   98000   -8413.3563   -8413.3563   -8494.5969   -8494.5969    314.40918    314.40918    23442.961    23442.961   -3381.3658   -3381.3658 
Loop time of 140.233 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.616 ns/day, 38.954 hours/ns, 7.131 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    | 139.63     | 139.63     | 139.63     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10721    | 0.10721    | 0.10721    |   0.0 |  0.08
Output  | 0.00024911 | 0.00024911 | 0.00024911 |   0.0 |  0.00
Modify  | 0.43156    | 0.43156    | 0.43156    |   0.0 |  0.31
Other   |            | 0.06518    |            |       |  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:      128232.0 ave      128232 max      128232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128232
Ave neighs/atom = 64.116000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.354800812405, Press = 1.145594139761
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   98000   -8413.3563   -8413.3563   -8494.5969   -8494.5969    314.40918    314.40918    23442.961    23442.961   -3381.3658   -3381.3658 
   99000   -8414.3284   -8414.3284   -8495.2148   -8495.2148    313.03896    313.03896    23429.758    23429.758   -2440.6776   -2440.6776 
Loop time of 130.824 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.660 ns/day, 36.340 hours/ns, 7.644 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.27     | 130.27     | 130.27     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10067    | 0.10067    | 0.10067    |   0.0 |  0.08
Output  | 0.00018929 | 0.00018929 | 0.00018929 |   0.0 |  0.00
Modify  | 0.39045    | 0.39045    | 0.39045    |   0.0 |  0.30
Other   |            | 0.0613     |            |       |  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:      128212.0 ave      128212 max      128212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128212
Ave neighs/atom = 64.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 = 313.34253920351, Press = 1.99663040715869
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
   99000   -8414.3284   -8414.3284   -8495.2148   -8495.2148    313.03896    313.03896    23429.758    23429.758   -2440.6776   -2440.6776 
  100000   -8413.3733   -8413.3733   -8494.0155   -8494.0155    312.09359    312.09359    23395.646    23395.646    212.33742    212.33742 
Loop time of 123.272 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.701 ns/day, 34.242 hours/ns, 8.112 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.76     | 122.76     | 122.76     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096603   | 0.096603   | 0.096603   |   0.0 |  0.08
Output  | 0.00015771 | 0.00015771 | 0.00015771 |   0.0 |  0.00
Modify  | 0.35819    | 0.35819    | 0.35819    |   0.0 |  0.29
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:      128234.0 ave      128234 max      128234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128234
Ave neighs/atom = 64.117000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.327630209774, Press = 1.57127254971745
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  100000   -8413.3733   -8413.3733   -8494.0155   -8494.0155    312.09359    312.09359    23395.646    23395.646    212.33742    212.33742 
  101000   -8413.1366   -8413.1366   -8495.7805   -8495.7805    319.84048    319.84048     23382.35     23382.35    979.97427    979.97427 
Loop time of 130.285 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.663 ns/day, 36.190 hours/ns, 7.675 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129.74     | 129.74     | 129.74     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10142    | 0.10142    | 0.10142    |   0.0 |  0.08
Output  | 0.00015592 | 0.00015592 | 0.00015592 |   0.0 |  0.00
Modify  | 0.38671    | 0.38671    | 0.38671    |   0.0 |  0.30
Other   |            | 0.06166    |            |       |  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:      128266.0 ave      128266 max      128266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128266
Ave neighs/atom = 64.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 = 313.345952755856, Press = 1.24340453399797
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  101000   -8413.1366   -8413.1366   -8495.7805   -8495.7805    319.84048    319.84048     23382.35     23382.35    979.97427    979.97427 
  102000   -8411.6596   -8411.6596   -8493.7271   -8493.7271    317.60971    317.60971    23374.731    23374.731    1811.2996    1811.2996 
Loop time of 121.268 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.712 ns/day, 33.685 hours/ns, 8.246 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.76     | 120.76     | 120.76     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095065   | 0.095065   | 0.095065   |   0.0 |  0.08
Output  | 0.00015444 | 0.00015444 | 0.00015444 |   0.0 |  0.00
Modify  | 0.35145    | 0.35145    | 0.35145    |   0.0 |  0.29
Other   |            | 0.05801    |            |       |  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:      128186.0 ave      128186 max      128186 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128186
Ave neighs/atom = 64.093000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.358443548463, Press = 0.88149458965048
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  102000   -8411.6596   -8411.6596   -8493.7271   -8493.7271    317.60971    317.60971    23374.731    23374.731    1811.2996    1811.2996 
  103000   -8414.8078   -8414.8078    -8494.149    -8494.149    307.05889    307.05889     23361.82     23361.82    2531.6943    2531.6943 
Loop time of 139.218 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.621 ns/day, 38.672 hours/ns, 7.183 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.62     | 138.62     | 138.62     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1059     | 0.1059     | 0.1059     |   0.0 |  0.08
Output  | 0.00019213 | 0.00019213 | 0.00019213 |   0.0 |  0.00
Modify  | 0.42392    | 0.42392    | 0.42392    |   0.0 |  0.30
Other   |            | 0.06343    |            |       |  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:      128254.0 ave      128254 max      128254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128254
Ave neighs/atom = 64.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 = 313.383386076847, Press = 0.245722897978625
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  103000   -8414.8078   -8414.8078    -8494.149    -8494.149    307.05889    307.05889     23361.82     23361.82    2531.6943    2531.6943 
  104000   -8415.8368   -8415.8368   -8495.7287   -8495.7287    309.19011    309.19011    23393.188    23393.188    63.900449    63.900449 
Loop time of 141.489 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.611 ns/day, 39.303 hours/ns, 7.068 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    | 140.88     | 140.88     | 140.88     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10729    | 0.10729    | 0.10729    |   0.0 |  0.08
Output  | 0.00019477 | 0.00019477 | 0.00019477 |   0.0 |  0.00
Modify  | 0.43793    | 0.43793    | 0.43793    |   0.0 |  0.31
Other   |            | 0.06424    |            |       |  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:      128260.0 ave      128260 max      128260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128260
Ave neighs/atom = 64.130000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.403397587705, Press = -0.147101389683331
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  104000   -8415.8368   -8415.8368   -8495.7287   -8495.7287    309.19011    309.19011    23393.188    23393.188    63.900449    63.900449 
  105000   -8415.9929   -8415.9929   -8495.1911   -8495.1911    306.50542    306.50542    23407.426    23407.426   -856.50571   -856.50571 
Loop time of 126.286 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.684 ns/day, 35.079 hours/ns, 7.919 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.76     | 125.76     | 125.76     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098047   | 0.098047   | 0.098047   |   0.0 |  0.08
Output  | 0.00015374 | 0.00015374 | 0.00015374 |   0.0 |  0.00
Modify  | 0.3725     | 0.3725     | 0.3725     |   0.0 |  0.29
Other   |            | 0.06014    |            |       |  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:      128224.0 ave      128224 max      128224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128224
Ave neighs/atom = 64.112000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.412594181988, Press = 0.671790354560842
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  105000   -8415.9929   -8415.9929   -8495.1911   -8495.1911    306.50542    306.50542    23407.426    23407.426   -856.50571   -856.50571 
  106000   -8417.7321   -8417.7321   -8497.8849   -8497.8849    310.19975    310.19975    23408.772    23408.772   -1317.6212   -1317.6212 
Loop time of 132.092 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.654 ns/day, 36.692 hours/ns, 7.570 timesteps/s
99.9% 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.53     | 131.53     | 131.53     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10192    | 0.10192    | 0.10192    |   0.0 |  0.08
Output  | 0.00015337 | 0.00015337 | 0.00015337 |   0.0 |  0.00
Modify  | 0.39508    | 0.39508    | 0.39508    |   0.0 |  0.30
Other   |            | 0.06179    |            |       |  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:      128216.0 ave      128216 max      128216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128216
Ave neighs/atom = 64.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 = 313.395483801189, Press = 0.986872516630223
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  106000   -8417.7321   -8417.7321   -8497.8849   -8497.8849    310.19975    310.19975    23408.772    23408.772   -1317.6212   -1317.6212 
  107000   -8414.0703   -8414.0703   -8494.2903   -8494.2903     310.4599     310.4599    23391.776    23391.776    444.90836    444.90836 
Loop time of 136.646 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.632 ns/day, 37.957 hours/ns, 7.318 timesteps/s
99.9% 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.06     | 136.06     | 136.06     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10452    | 0.10452    | 0.10452    |   0.0 |  0.08
Output  | 0.00018759 | 0.00018759 | 0.00018759 |   0.0 |  0.00
Modify  | 0.41376    | 0.41376    | 0.41376    |   0.0 |  0.30
Other   |            | 0.0629     |            |       |  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:      128226.0 ave      128226 max      128226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128226
Ave neighs/atom = 64.113000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.379511366588, Press = 1.32787810208577
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  107000   -8414.0703   -8414.0703   -8494.2903   -8494.2903     310.4599     310.4599    23391.776    23391.776    444.90836    444.90836 
  108000   -8411.3168   -8411.3168   -8493.4095   -8493.4095    317.70744    317.70744    23356.702    23356.702    3185.7593    3185.7593 
Loop time of 134.115 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.644 ns/day, 37.254 hours/ns, 7.456 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.55     | 133.55     | 133.55     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10266    | 0.10266    | 0.10266    |   0.0 |  0.08
Output  | 0.0001557  | 0.0001557  | 0.0001557  |   0.0 |  0.00
Modify  | 0.40402    | 0.40402    | 0.40402    |   0.0 |  0.30
Other   |            | 0.06275    |            |       |  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:      128210.0 ave      128210 max      128210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128210
Ave neighs/atom = 64.105000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.366451264255, Press = 1.35523017099626
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  108000   -8411.3168   -8411.3168   -8493.4095   -8493.4095    317.70744    317.70744    23356.702    23356.702    3185.7593    3185.7593 
  109000      -8414.3      -8414.3   -8494.1049   -8494.1049     308.8532     308.8532    23329.242    23329.242    4921.3284    4921.3284 
Loop time of 137.01 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.631 ns/day, 38.058 hours/ns, 7.299 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.43     | 136.43     | 136.43     |   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.00015505 | 0.00015505 | 0.00015505 |   0.0 |  0.00
Modify  | 0.41001    | 0.41001    | 0.41001    |   0.0 |  0.30
Other   |            | 0.06423    |            |       |  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:      128304.0 ave      128304 max      128304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128304
Ave neighs/atom = 64.152000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.37071620222, Press = 0.662857461679875
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  109000      -8414.3      -8414.3   -8494.1049   -8494.1049     308.8532     308.8532    23329.242    23329.242    4921.3284    4921.3284 
  110000   -8410.7122   -8410.7122   -8493.3185   -8493.3185    319.69484    319.69484    23384.344    23384.344     1223.917     1223.917 
Loop time of 121.543 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.711 ns/day, 33.762 hours/ns, 8.228 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.04     | 121.04     | 121.04     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095694   | 0.095694   | 0.095694   |   0.0 |  0.08
Output  | 0.00015541 | 0.00015541 | 0.00015541 |   0.0 |  0.00
Modify  | 0.35225    | 0.35225    | 0.35225    |   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:      128330.0 ave      128330 max      128330 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128330
Ave neighs/atom = 64.165000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.392660530691, Press = 0.534494192162691
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  110000   -8410.7122   -8410.7122   -8493.3185   -8493.3185    319.69484    319.69484    23384.344    23384.344     1223.917     1223.917 
  111000   -8414.6858   -8414.6858   -8495.0507   -8495.0507     311.0203     311.0203    23402.541    23402.541   -565.17891   -565.17891 
Loop time of 125.664 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.688 ns/day, 34.907 hours/ns, 7.958 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.14     | 125.14     | 125.14     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097396   | 0.097396   | 0.097396   |   0.0 |  0.08
Output  | 0.00025281 | 0.00025281 | 0.00025281 |   0.0 |  0.00
Modify  | 0.37018    | 0.37018    | 0.37018    |   0.0 |  0.29
Other   |            | 0.06077    |            |       |  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:      128284.0 ave      128284 max      128284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128284
Ave neighs/atom = 64.142000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.411540770871, Press = 0.524280383105814
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  111000   -8414.6858   -8414.6858   -8495.0507   -8495.0507     311.0203     311.0203    23402.541    23402.541   -565.17891   -565.17891 
  112000   -8411.0982   -8411.0982   -8493.9038   -8493.9038    320.46638    320.46638    23420.806    23420.806   -1451.1538   -1451.1538 
Loop time of 138.13 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.625 ns/day, 38.370 hours/ns, 7.240 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    | 137.54     | 137.54     | 137.54     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10569    | 0.10569    | 0.10569    |   0.0 |  0.08
Output  | 0.00047031 | 0.00047031 | 0.00047031 |   0.0 |  0.00
Modify  | 0.41995    | 0.41995    | 0.41995    |   0.0 |  0.30
Other   |            | 0.06446    |            |       |  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:      128222.0 ave      128222 max      128222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128222
Ave neighs/atom = 64.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 = 313.415407563861, Press = 0.834315282819364
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  112000   -8411.0982   -8411.0982   -8493.9038   -8493.9038    320.46638    320.46638    23420.806    23420.806   -1451.1538   -1451.1538 
  113000   -8414.4089   -8414.4089   -8495.3164   -8495.3164    313.12012    313.12012     23415.99     23415.99   -1465.4055   -1465.4055 
Loop time of 138.54 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.624 ns/day, 38.483 hours/ns, 7.218 timesteps/s
99.9% 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.94     | 137.94     | 137.94     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10579    | 0.10579    | 0.10579    |   0.0 |  0.08
Output  | 0.00017208 | 0.00017208 | 0.00017208 |   0.0 |  0.00
Modify  | 0.42526    | 0.42526    | 0.42526    |   0.0 |  0.31
Other   |            | 0.06437    |            |       |  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:      128274.0 ave      128274 max      128274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128274
Ave neighs/atom = 64.137000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.40515137651, Press = 1.38975144427382
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  113000   -8414.4089   -8414.4089   -8495.3164   -8495.3164    313.12012    313.12012     23415.99     23415.99   -1465.4055   -1465.4055 
  114000   -8416.4719   -8416.4719   -8495.2183   -8495.2183    304.75677    304.75677    23375.159    23375.159     1421.543     1421.543 
Loop time of 134.361 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.643 ns/day, 37.323 hours/ns, 7.443 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.79     | 133.79     | 133.79     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10242    | 0.10242    | 0.10242    |   0.0 |  0.08
Output  | 0.00019136 | 0.00019136 | 0.00019136 |   0.0 |  0.00
Modify  | 0.40514    | 0.40514    | 0.40514    |   0.0 |  0.30
Other   |            | 0.06197    |            |       |  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:      128270.0 ave      128270 max      128270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128270
Ave neighs/atom = 64.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 = 313.392619121231, Press = 1.93357348570799
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  114000   -8416.4719   -8416.4719   -8495.2183   -8495.2183    304.75677    304.75677    23375.159    23375.159     1421.543     1421.543 
  115000   -8415.0635   -8415.0635   -8494.4842   -8494.4842    307.36602    307.36602    23353.197    23353.197    3185.8517    3185.8517 
Loop time of 128.048 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.675 ns/day, 35.569 hours/ns, 7.810 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.51     | 127.51     | 127.51     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098578   | 0.098578   | 0.098578   |   0.0 |  0.08
Output  | 0.00015655 | 0.00015655 | 0.00015655 |   0.0 |  0.00
Modify  | 0.37754    | 0.37754    | 0.37754    |   0.0 |  0.29
Other   |            | 0.06177    |            |       |  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:      128270.0 ave      128270 max      128270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128270
Ave neighs/atom = 64.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 = 313.359652516133, Press = 1.46913923731953
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  115000   -8415.0635   -8415.0635   -8494.4842   -8494.4842    307.36602    307.36602    23353.197    23353.197    3185.8517    3185.8517 
  116000   -8414.1255   -8414.1255   -8495.8539   -8495.8539    316.29739    316.29739     23365.79     23365.79    2156.3499    2156.3499 
Loop time of 125.091 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.691 ns/day, 34.748 hours/ns, 7.994 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.57     | 124.57     | 124.57     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096951   | 0.096951   | 0.096951   |   0.0 |  0.08
Output  | 0.00015736 | 0.00015736 | 0.00015736 |   0.0 |  0.00
Modify  | 0.36589    | 0.36589    | 0.36589    |   0.0 |  0.29
Other   |            | 0.06053    |            |       |  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:      128306.0 ave      128306 max      128306 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128306
Ave neighs/atom = 64.153000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.361427607717, Press = 0.764887302722453
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  116000   -8414.1255   -8414.1255   -8495.8539   -8495.8539    316.29739    316.29739     23365.79     23365.79    2156.3499    2156.3499 
  117000   -8417.3879   -8417.3879   -8495.2992   -8495.2992    301.52496    301.52496    23383.661    23383.661    792.12916    792.12916 
Loop time of 131.523 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.657 ns/day, 36.534 hours/ns, 7.603 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 130.97     | 130.97     | 130.97     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10074    | 0.10074    | 0.10074    |   0.0 |  0.08
Output  | 0.00015401 | 0.00015401 | 0.00015401 |   0.0 |  0.00
Modify  | 0.39302    | 0.39302    | 0.39302    |   0.0 |  0.30
Other   |            | 0.0616     |            |       |  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:      128242.0 ave      128242 max      128242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128242
Ave neighs/atom = 64.121000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.330803956497, Press = 0.554078821902607
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  117000   -8417.3879   -8417.3879   -8495.2992   -8495.2992    301.52496    301.52496    23383.661    23383.661    792.12916    792.12916 
  118000   -8412.5143   -8412.5143   -8495.8498   -8495.8498    322.51724    322.51724     23408.79     23408.79   -836.90823   -836.90823 
Loop time of 121.843 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.709 ns/day, 33.845 hours/ns, 8.207 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.34     | 121.34     | 121.34     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093349   | 0.093349   | 0.093349   |   0.0 |  0.08
Output  | 0.00015661 | 0.00015661 | 0.00015661 |   0.0 |  0.00
Modify  | 0.34958    | 0.34958    | 0.34958    |   0.0 |  0.29
Other   |            | 0.05994    |            |       |  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:      128202.0 ave      128202 max      128202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128202
Ave neighs/atom = 64.101000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.329247521234, Press = 0.558142077000195
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  118000   -8412.5143   -8412.5143   -8495.8498   -8495.8498    322.51724    322.51724     23408.79     23408.79   -836.90823   -836.90823 
  119000   -8413.9967   -8413.9967   -8496.1368   -8496.1368    317.89083    317.89083    23455.834    23455.834   -4432.8292   -4432.8292 
Loop time of 140.924 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.613 ns/day, 39.146 hours/ns, 7.096 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    | 140.31     | 140.31     | 140.31     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10855    | 0.10855    | 0.10855    |   0.0 |  0.08
Output  | 0.00015552 | 0.00015552 | 0.00015552 |   0.0 |  0.00
Modify  | 0.43567    | 0.43567    | 0.43567    |   0.0 |  0.31
Other   |            | 0.06486    |            |       |  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:      128196.0 ave      128196 max      128196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128196
Ave neighs/atom = 64.098000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.333133451058, Press = 0.453633188728528
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  119000   -8413.9967   -8413.9967   -8496.1368   -8496.1368    317.89083    317.89083    23455.834    23455.834   -4432.8292   -4432.8292 
  120000   -8412.5429   -8412.5429   -8493.1025   -8493.1025    311.77407    311.77407    23448.278    23448.278   -3475.3151   -3475.3151 
Loop time of 141.981 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.609 ns/day, 39.439 hours/ns, 7.043 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    | 141.37     | 141.37     | 141.37     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10829    | 0.10829    | 0.10829    |   0.0 |  0.08
Output  | 0.0001559  | 0.0001559  | 0.0001559  |   0.0 |  0.00
Modify  | 0.43872    | 0.43872    | 0.43872    |   0.0 |  0.31
Other   |            | 0.06518    |            |       |  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:      128180.0 ave      128180 max      128180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128180
Ave neighs/atom = 64.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 = 313.329654889579, Press = 1.24222834260241
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  120000   -8412.5429   -8412.5429   -8493.1025   -8493.1025    311.77407    311.77407    23448.278    23448.278   -3475.3151   -3475.3151 
  121000   -8412.6554   -8412.6554   -8493.8117   -8493.8117    314.08314    314.08314    23408.857    23408.857   -745.16392   -745.16392 
Loop time of 141.576 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.610 ns/day, 39.327 hours/ns, 7.063 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    | 140.96     | 140.96     | 140.96     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10741    | 0.10741    | 0.10741    |   0.0 |  0.08
Output  | 0.00015482 | 0.00015482 | 0.00015482 |   0.0 |  0.00
Modify  | 0.43976    | 0.43976    | 0.43976    |   0.0 |  0.31
Other   |            | 0.06515    |            |       |  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:      128236.0 ave      128236 max      128236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128236
Ave neighs/atom = 64.118000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.331623543245, Press = 1.4151111055196
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  121000   -8412.6554   -8412.6554   -8493.8117   -8493.8117    314.08314    314.08314    23408.857    23408.857   -745.16392   -745.16392 
  122000   -8411.1278   -8411.1278   -8493.4657   -8493.4657    318.65598    318.65598     23386.98     23386.98    1000.3338    1000.3338 
Loop time of 141.67 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.610 ns/day, 39.353 hours/ns, 7.059 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    | 141.06     | 141.06     | 141.06     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10856    | 0.10856    | 0.10856    |   0.0 |  0.08
Output  | 0.00021492 | 0.00021492 | 0.00021492 |   0.0 |  0.00
Modify  | 0.44021    | 0.44021    | 0.44021    |   0.0 |  0.31
Other   |            | 0.06509    |            |       |  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:      128258.0 ave      128258 max      128258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128258
Ave neighs/atom = 64.129000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.338628420858, Press = 1.22979012318138
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  122000   -8411.1278   -8411.1278   -8493.4657   -8493.4657    318.65598    318.65598     23386.98     23386.98    1000.3338    1000.3338 
  123000   -8416.2823   -8416.2823   -8496.9233   -8496.9233    312.08906    312.08906    23373.199    23373.199    1452.9942    1452.9942 
Loop time of 141.944 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.609 ns/day, 39.429 hours/ns, 7.045 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    | 141.33     | 141.33     | 141.33     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1084     | 0.1084     | 0.1084     |   0.0 |  0.08
Output  | 0.00015765 | 0.00015765 | 0.00015765 |   0.0 |  0.00
Modify  | 0.43842    | 0.43842    | 0.43842    |   0.0 |  0.31
Other   |            | 0.06447    |            |       |  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:      128274.0 ave      128274 max      128274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128274
Ave neighs/atom = 64.137000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.320238204927, Press = 0.852051559036466
next a
jump SELF top
variable a loop 2000
run 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
  ghost atom cutoff = 6
  binsize = 3, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      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 
  123000   -8416.2823   -8416.2823   -8496.9233   -8496.9233    312.08906    312.08906    23373.199    23373.199    1452.9942    1452.9942 
  124000   -8415.0214   -8415.0214   -8496.0793   -8496.0793     313.7025     313.7025    23371.602    23371.602    1618.7098    1618.7098 
Loop time of 126.252 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.684 ns/day, 35.070 hours/ns, 7.921 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.72     | 125.72     | 125.72     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096547   | 0.096547   | 0.096547   |   0.0 |  0.08
Output  | 0.00015666 | 0.00015666 | 0.00015666 |   0.0 |  0.00
Modify  | 0.36829    | 0.36829    | 0.36829    |   0.0 |  0.29
Other   |            | 0.06176    |            |       |  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:      128240.0 ave      128240 max      128240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128240
Ave neighs/atom = 64.120000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
23397.0514216253

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0