# 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.004 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 293.15*${_u_temperature}
variable temp_converted equal 293.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_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   -8504.2526   -8504.2526   -8579.9999   -8579.9999       293.15       293.15    23173.502    23173.502    3491.3663    3491.3663 
    1000   -8423.7822   -8423.7822   -8499.3333   -8499.3333    292.39071    292.39071    23349.336    23349.336    2372.6206    2372.6206 
Loop time of 116.432 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.742 ns/day, 32.342 hours/ns, 8.589 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 115.94     | 115.94     | 115.94     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096201   | 0.096201   | 0.096201   |   0.0 |  0.08
Output  | 0.00019969 | 0.00019969 | 0.00019969 |   0.0 |  0.00
Modify  | 0.33665    | 0.33665    | 0.33665    |   0.0 |  0.29
Other   |            | 0.06079    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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   -8423.7822   -8423.7822   -8499.3333   -8499.3333    292.39071    292.39071    23349.336    23349.336    2372.6206    2372.6206 
    2000   -8424.9968   -8424.9968   -8501.2521   -8501.2521    295.11605    295.11605    23364.534    23364.534    1315.4631    1315.4631 
Loop time of 124.867 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.692 ns/day, 34.685 hours/ns, 8.009 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.36     | 124.36     | 124.36     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09968    | 0.09968    | 0.09968    |   0.0 |  0.08
Output  | 0.0001966  | 0.0001966  | 0.0001966  |   0.0 |  0.00
Modify  | 0.34904    | 0.34904    | 0.34904    |   0.0 |  0.28
Other   |            | 0.05884    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 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   -8424.9968   -8424.9968   -8501.2521   -8501.2521    295.11605    295.11605    23364.534    23364.534    1315.4631    1315.4631 
    3000   -8425.7429   -8425.7429   -8498.8919   -8498.8919    283.09387    283.09387    23386.394    23386.394   -347.65383   -347.65383 
Loop time of 128.087 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.675 ns/day, 35.580 hours/ns, 7.807 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.56     | 127.56     | 127.56     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1003     | 0.1003     | 0.1003     |   0.0 |  0.08
Output  | 0.00019202 | 0.00019202 | 0.00019202 |   0.0 |  0.00
Modify  | 0.36432    | 0.36432    | 0.36432    |   0.0 |  0.28
Other   |            | 0.06137    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 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   -8425.7429   -8425.7429   -8498.8919   -8498.8919    283.09387    283.09387    23386.394    23386.394   -347.65383   -347.65383 
    4000    -8423.636    -8423.636   -8498.9259   -8498.9259    291.37955    291.37955    23414.696    23414.696   -2205.4309   -2205.4309 
Loop time of 120.879 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.715 ns/day, 33.577 hours/ns, 8.273 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.39     | 120.39     | 120.39     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096348   | 0.096348   | 0.096348   |   0.0 |  0.08
Output  | 0.0001878  | 0.0001878  | 0.0001878  |   0.0 |  0.00
Modify  | 0.33427    | 0.33427    | 0.33427    |   0.0 |  0.28
Other   |            | 0.05902    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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    -8423.636    -8423.636   -8498.9259   -8498.9259    291.37955    291.37955    23414.696    23414.696   -2205.4309   -2205.4309 
    5000   -8426.4994   -8426.4994   -8501.7284   -8501.7284    291.14404    291.14404    23414.247    23414.247   -2610.0434   -2610.0434 
Loop time of 122.335 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.706 ns/day, 33.982 hours/ns, 8.174 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.83     | 121.83     | 121.83     |   0.0 | 99.59
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097596   | 0.097596   | 0.097596   |   0.0 |  0.08
Output  | 0.00019182 | 0.00019182 | 0.00019182 |   0.0 |  0.00
Modify  | 0.34365    | 0.34365    | 0.34365    |   0.0 |  0.28
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:      128154.0 ave      128154 max      128154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128154
Ave neighs/atom = 64.077000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.208832674932, Press = 250.683317598192
next a
jump SELF top
variable a loop 2000
run 1000
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   -8426.4994   -8426.4994   -8501.7284   -8501.7284    291.14404    291.14404    23414.247    23414.247   -2610.0434   -2610.0434 
    6000   -8424.5931   -8424.5931   -8501.1552   -8501.1552    296.30323    296.30323    23392.169    23392.169   -804.63176   -804.63176 
Loop time of 128.877 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.670 ns/day, 35.799 hours/ns, 7.759 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.33     | 128.33     | 128.33     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10124    | 0.10124    | 0.10124    |   0.0 |  0.08
Output  | 0.00025978 | 0.00025978 | 0.00025978 |   0.0 |  0.00
Modify  | 0.38524    | 0.38524    | 0.38524    |   0.0 |  0.30
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:      128140.0 ave      128140 max      128140 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128140
Ave neighs/atom = 64.070000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 291.765869268167, Press = 9.3392603333067
next a
jump SELF top
variable a loop 2000
run 1000
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   -8424.5931   -8424.5931   -8501.1552   -8501.1552    296.30323    296.30323    23392.169    23392.169   -804.63176   -804.63176 
    7000   -8425.1053   -8425.1053   -8500.5873   -8500.5873    292.12287    292.12287    23376.534    23376.534    313.44284    313.44284 
Loop time of 140.948 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.613 ns/day, 39.152 hours/ns, 7.095 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.34     | 140.34     | 140.34     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10756    | 0.10756    | 0.10756    |   0.0 |  0.08
Output  | 0.00024176 | 0.00024176 | 0.00024176 |   0.0 |  0.00
Modify  | 0.43684    | 0.43684    | 0.43684    |   0.0 |  0.31
Other   |            | 0.06589    |            |       |  0.05

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

Total # of neighbors = 128188
Ave neighs/atom = 64.094000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.710096573795, Press = 11.7655350721921
next a
jump SELF top
variable a loop 2000
run 1000
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   -8425.1053   -8425.1053   -8500.5873   -8500.5873    292.12287    292.12287    23376.534    23376.534    313.44284    313.44284 
    8000   -8424.5352   -8424.5352   -8499.6458   -8499.6458    290.68582    290.68582    23368.608    23368.608    1096.8196    1096.8196 
Loop time of 141.194 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.612 ns/day, 39.221 hours/ns, 7.082 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.58     | 140.58     | 140.58     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10852    | 0.10852    | 0.10852    |   0.0 |  0.08
Output  | 0.00015457 | 0.00015457 | 0.00015457 |   0.0 |  0.00
Modify  | 0.43446    | 0.43446    | 0.43446    |   0.0 |  0.31
Other   |            | 0.06617    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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 = 292.699871490841, Press = 14.9471755644061
next a
jump SELF top
variable a loop 2000
run 1000
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   -8424.5352   -8424.5352   -8499.6458   -8499.6458    290.68582    290.68582    23368.608    23368.608    1096.8196    1096.8196 
    9000   -8423.4984   -8423.4984    -8501.912    -8501.912    303.46872    303.46872    23381.187    23381.187    76.239073    76.239073 
Loop time of 130.105 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.664 ns/day, 36.140 hours/ns, 7.686 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 129.55     | 129.55     | 129.55     |   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.00015603 | 0.00015603 | 0.00015603 |   0.0 |  0.00
Modify  | 0.38606    | 0.38606    | 0.38606    |   0.0 |  0.30
Other   |            | 0.06262    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.435957727061, Press = 9.61915743749951
next a
jump SELF top
variable a loop 2000
run 1000
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   -8423.4984   -8423.4984    -8501.912    -8501.912    303.46872    303.46872    23381.187    23381.187    76.239073    76.239073 
   10000   -8420.8927   -8420.8927   -8496.3161   -8496.3161    291.89616    291.89616     23391.92     23391.92   -141.51104   -141.51104 
Loop time of 121.216 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.671 hours/ns, 8.250 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.71     | 120.71     | 120.71     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096723   | 0.096723   | 0.096723   |   0.0 |  0.08
Output  | 0.00015528 | 0.00015528 | 0.00015528 |   0.0 |  0.00
Modify  | 0.34955    | 0.34955    | 0.34955    |   0.0 |  0.29
Other   |            | 0.05915    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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 = 292.521298167833, Press = 8.81715475402051
next a
jump SELF top
variable a loop 2000
run 1000
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   -8420.8927   -8420.8927   -8496.3161   -8496.3161    291.89616    291.89616     23391.92     23391.92   -141.51104   -141.51104 
   11000   -8425.0551   -8425.0551   -8501.7877   -8501.7877    296.96323    296.96323     23392.12     23392.12   -862.95386   -862.95386 
Loop time of 120.579 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.717 ns/day, 33.494 hours/ns, 8.293 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.07     | 120.07     | 120.07     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096389   | 0.096389   | 0.096389   |   0.0 |  0.08
Output  | 0.0001566  | 0.0001566  | 0.0001566  |   0.0 |  0.00
Modify  | 0.34886    | 0.34886    | 0.34886    |   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:      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 = 293.005350743802, Press = 5.3758621239821
next a
jump SELF top
variable a loop 2000
run 1000
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   -8425.0551   -8425.0551   -8501.7877   -8501.7877    296.96323    296.96323     23392.12     23392.12   -862.95386   -862.95386 
   12000   -8423.7519   -8423.7519   -8498.6213   -8498.6213    289.75225    289.75225    23407.257    23407.257    -1652.249    -1652.249 
Loop time of 120.991 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.609 hours/ns, 8.265 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.49     | 120.49     | 120.49     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095911   | 0.095911   | 0.095911   |   0.0 |  0.08
Output  | 0.00015523 | 0.00015523 | 0.00015523 |   0.0 |  0.00
Modify  | 0.34929    | 0.34929    | 0.34929    |   0.0 |  0.29
Other   |            | 0.05826    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.978355284367, Press = 4.90239110868326
next a
jump SELF top
variable a loop 2000
run 1000
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   -8423.7519   -8423.7519   -8498.6213   -8498.6213    289.75225    289.75225    23407.257    23407.257    -1652.249    -1652.249 
   13000   -8425.9918   -8425.9918   -8500.4889   -8500.4889    288.31127    288.31127    23417.415    23417.415   -2691.8419   -2691.8419 
Loop time of 120.582 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.717 ns/day, 33.495 hours/ns, 8.293 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.08     | 120.08     | 120.08     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096373   | 0.096373   | 0.096373   |   0.0 |  0.08
Output  | 0.00015633 | 0.00015633 | 0.00015633 |   0.0 |  0.00
Modify  | 0.35014    | 0.35014    | 0.35014    |   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:      128188.0 ave      128188 max      128188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128188
Ave neighs/atom = 64.094000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.909650333267, Press = 2.04600814373691
next a
jump SELF top
variable a loop 2000
run 1000
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   -8425.9918   -8425.9918   -8500.4889   -8500.4889    288.31127    288.31127    23417.415    23417.415   -2691.8419   -2691.8419 
   14000   -8425.0941   -8425.0941   -8500.3334   -8500.3334    291.18405    291.18405    23409.858    23409.858   -2105.3134   -2105.3134 
Loop time of 121.418 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.712 ns/day, 33.727 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.096529   | 0.096529   | 0.096529   |   0.0 |  0.08
Output  | 0.00015345 | 0.00015345 | 0.00015345 |   0.0 |  0.00
Modify  | 0.35366    | 0.35366    | 0.35366    |   0.0 |  0.29
Other   |            | 0.05816    |            |       |  0.05

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

Total # of neighbors = 128162
Ave neighs/atom = 64.081000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.963243420944, Press = -2.28711929005552
next a
jump SELF top
variable a loop 2000
run 1000
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   -8425.0941   -8425.0941   -8500.3334   -8500.3334    291.18405    291.18405    23409.858    23409.858   -2105.3134   -2105.3134 
   15000   -8425.1053   -8425.1053   -8502.0536   -8502.0536    297.79781    297.79781    23390.014    23390.014   -777.69608   -777.69608 
Loop time of 121.053 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.626 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.095995   | 0.095995   | 0.095995   |   0.0 |  0.08
Output  | 0.00018899 | 0.00018899 | 0.00018899 |   0.0 |  0.00
Modify  | 0.35193    | 0.35193    | 0.35193    |   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:      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 = 292.87799466538, Press = -3.76815394541835
next a
jump SELF top
variable a loop 2000
run 1000
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   -8425.1053   -8425.1053   -8502.0536   -8502.0536    297.79781    297.79781    23390.014    23390.014   -777.69608   -777.69608 
   16000   -8426.3029   -8426.3029   -8502.3676   -8502.3676    294.37815    294.37815    23369.362    23369.362    625.82284    625.82284 
Loop time of 120.986 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.607 hours/ns, 8.265 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.48     | 120.48     | 120.48     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095488   | 0.095488   | 0.095488   |   0.0 |  0.08
Output  | 0.00015591 | 0.00015591 | 0.00015591 |   0.0 |  0.00
Modify  | 0.35083    | 0.35083    | 0.35083    |   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:      128176.0 ave      128176 max      128176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128176
Ave neighs/atom = 64.088000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.921321716199, Press = -1.25062198519089
next a
jump SELF top
variable a loop 2000
run 1000
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   -8426.3029   -8426.3029   -8502.3676   -8502.3676    294.37815    294.37815    23369.362    23369.362    625.82284    625.82284 
   17000   -8421.4902   -8421.4902   -8499.1733   -8499.1733    300.64141    300.64141    23369.574    23369.574    1172.8075    1172.8075 
Loop time of 120.914 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.715 ns/day, 33.587 hours/ns, 8.270 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.41     | 120.41     | 120.41     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096892   | 0.096892   | 0.096892   |   0.0 |  0.08
Output  | 0.00015549 | 0.00015549 | 0.00015549 |   0.0 |  0.00
Modify  | 0.35199    | 0.35199    | 0.35199    |   0.0 |  0.29
Other   |            | 0.0581     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 293.097527283611, Press = 1.46991994696207
next a
jump SELF top
variable a loop 2000
run 1000
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   -8421.4902   -8421.4902   -8499.1733   -8499.1733    300.64141    300.64141    23369.574    23369.574    1172.8075    1172.8075 
   18000   -8426.9439   -8426.9439   -8501.9528   -8501.9528    290.29251    290.29251    23360.138    23360.138    1227.5412    1227.5412 
Loop time of 120.938 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.594 hours/ns, 8.269 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.43     | 120.43     | 120.43     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096816   | 0.096816   | 0.096816   |   0.0 |  0.08
Output  | 0.00018993 | 0.00018993 | 0.00018993 |   0.0 |  0.00
Modify  | 0.35166    | 0.35166    | 0.35166    |   0.0 |  0.29
Other   |            | 0.05917    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 293.148056670152, Press = 1.93735221444368
next a
jump SELF top
variable a loop 2000
run 1000
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   -8426.9439   -8426.9439   -8501.9528   -8501.9528    290.29251    290.29251    23360.138    23360.138    1227.5412    1227.5412 
   19000   -8425.8811   -8425.8811   -8501.4335   -8501.4335    292.39574    292.39574    23362.663    23362.663     1257.901     1257.901 
Loop time of 120.435 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.717 ns/day, 33.454 hours/ns, 8.303 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.93     | 119.93     | 119.93     |   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.00015449 | 0.00015449 | 0.00015449 |   0.0 |  0.00
Modify  | 0.34942    | 0.34942    | 0.34942    |   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:      128184.0 ave      128184 max      128184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128184
Ave neighs/atom = 64.092000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.105868682615, Press = 3.33049450735899
next a
jump SELF top
variable a loop 2000
run 1000
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   -8425.8811   -8425.8811   -8501.4335   -8501.4335    292.39574    292.39574    23362.663    23362.663     1257.901     1257.901 
   20000   -8424.7584   -8424.7584   -8501.0476   -8501.0476    295.24721    295.24721    23358.985    23358.985    1586.5907    1586.5907 
Loop time of 120.559 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.717 ns/day, 33.489 hours/ns, 8.295 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 120.05     | 120.05     | 120.05     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096478   | 0.096478   | 0.096478   |   0.0 |  0.08
Output  | 0.00015497 | 0.00015497 | 0.00015497 |   0.0 |  0.00
Modify  | 0.35008    | 0.35008    | 0.35008    |   0.0 |  0.29
Other   |            | 0.05868    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.928667161856, Press = 6.7049098729073
next a
jump SELF top
variable a loop 2000
run 1000
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   -8424.7584   -8424.7584   -8501.0476   -8501.0476    295.24721    295.24721    23358.985    23358.985    1586.5907    1586.5907 
   21000   -8423.8659   -8423.8659   -8499.3577   -8499.3577    292.16122    292.16122    23368.108    23368.108    1138.6286    1138.6286 
Loop time of 120.46 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.717 ns/day, 33.461 hours/ns, 8.301 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.96     | 119.96     | 119.96     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096454   | 0.096454   | 0.096454   |   0.0 |  0.08
Output  | 0.00015684 | 0.00015684 | 0.00015684 |   0.0 |  0.00
Modify  | 0.34942    | 0.34942    | 0.34942    |   0.0 |  0.29
Other   |            | 0.05875    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.847498262714, Press = 8.82265778892423
next a
jump SELF top
variable a loop 2000
run 1000
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   -8423.8659   -8423.8659   -8499.3577   -8499.3577    292.16122    292.16122    23368.108    23368.108    1138.6286    1138.6286 
   22000   -8424.9711   -8424.9711     -8498.97     -8498.97    286.38359    286.38359    23388.663    23388.663   -414.83478   -414.83478 
Loop time of 120.842 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.715 ns/day, 33.567 hours/ns, 8.275 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.34     | 120.34     | 120.34     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096173   | 0.096173   | 0.096173   |   0.0 |  0.08
Output  | 0.00018835 | 0.00018835 | 0.00018835 |   0.0 |  0.00
Modify  | 0.34979    | 0.34979    | 0.34979    |   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:      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 = 292.776050776888, Press = 6.03194672326925
next a
jump SELF top
variable a loop 2000
run 1000
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   -8424.9711   -8424.9711     -8498.97     -8498.97    286.38359    286.38359    23388.663    23388.663   -414.83478   -414.83478 
   23000    -8426.753    -8426.753   -8502.3453   -8502.3453     292.5499     292.5499    23391.266    23391.266   -1016.1448   -1016.1448 
Loop time of 120.586 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.717 ns/day, 33.496 hours/ns, 8.293 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.08     | 120.08     | 120.08     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095983   | 0.095983   | 0.095983   |   0.0 |  0.08
Output  | 0.00015559 | 0.00015559 | 0.00015559 |   0.0 |  0.00
Modify  | 0.34972    | 0.34972    | 0.34972    |   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:      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 = 292.790794361698, Press = 3.18840718780657
next a
jump SELF top
variable a loop 2000
run 1000
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    -8426.753    -8426.753   -8502.3453   -8502.3453     292.5499     292.5499    23391.266    23391.266   -1016.1448   -1016.1448 
   24000   -8424.7475   -8424.7475   -8500.8121   -8500.8121    294.37787    294.37787    23404.789    23404.789   -1723.4425   -1723.4425 
Loop time of 120.486 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.717 ns/day, 33.468 hours/ns, 8.300 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 119.98     | 119.98     | 119.98     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096236   | 0.096236   | 0.096236   |   0.0 |  0.08
Output  | 0.00015604 | 0.00015604 | 0.00015604 |   0.0 |  0.00
Modify  | 0.34909    | 0.34909    | 0.34909    |   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:      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 = 292.666872733741, Press = 1.38975341053705
next a
jump SELF top
variable a loop 2000
run 1000
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   -8424.7475   -8424.7475   -8500.8121   -8500.8121    294.37787    294.37787    23404.789    23404.789   -1723.4425   -1723.4425 
   25000   -8428.7312   -8428.7312   -8503.2476   -8503.2476    288.38619    288.38619    23395.157    23395.157   -1471.9273   -1471.9273 
Loop time of 120.613 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.716 ns/day, 33.504 hours/ns, 8.291 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.11     | 120.11     | 120.11     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096064   | 0.096064   | 0.096064   |   0.0 |  0.08
Output  | 0.00015337 | 0.00015337 | 0.00015337 |   0.0 |  0.00
Modify  | 0.34945    | 0.34945    | 0.34945    |   0.0 |  0.29
Other   |            | 0.0585     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.622285269228, Press = -0.09841232003833
next a
jump SELF top
variable a loop 2000
run 1000
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   -8428.7312   -8428.7312   -8503.2476   -8503.2476    288.38619    288.38619    23395.157    23395.157   -1471.9273   -1471.9273 
   26000   -8423.0075   -8423.0075   -8499.4104   -8499.4104    295.68691    295.68691     23407.72     23407.72   -1646.2755   -1646.2755 
Loop time of 120.834 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.715 ns/day, 33.565 hours/ns, 8.276 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.33     | 120.33     | 120.33     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096384   | 0.096384   | 0.096384   |   0.0 |  0.08
Output  | 0.00018762 | 0.00018762 | 0.00018762 |   0.0 |  0.00
Modify  | 0.35007    | 0.35007    | 0.35007    |   0.0 |  0.29
Other   |            | 0.05851    |            |       |  0.05

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

Total # of neighbors = 128166
Ave neighs/atom = 64.083000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.564994734065, Press = -1.5533692594013
next a
jump SELF top
variable a loop 2000
run 1000
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   -8423.0075   -8423.0075   -8499.4104   -8499.4104    295.68691    295.68691     23407.72     23407.72   -1646.2755   -1646.2755 
   27000   -8426.0223   -8426.0223   -8501.1813   -8501.1813    290.87285    290.87285     23377.29     23377.29    252.20187    252.20187 
Loop time of 120.531 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.717 ns/day, 33.481 hours/ns, 8.297 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.03     | 120.03     | 120.03     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096071   | 0.096071   | 0.096071   |   0.0 |  0.08
Output  | 0.00015591 | 0.00015591 | 0.00015591 |   0.0 |  0.00
Modify  | 0.34869    | 0.34869    | 0.34869    |   0.0 |  0.29
Other   |            | 0.05842    |            |       |  0.05

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

Total # of neighbors = 128168
Ave neighs/atom = 64.084000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.607697317712, Press = -1.85363984091173
next a
jump SELF top
variable a loop 2000
run 1000
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   -8426.0223   -8426.0223   -8501.1813   -8501.1813    290.87285    290.87285     23377.29     23377.29    252.20187    252.20187 
   28000   -8423.5441   -8423.5441   -8499.6189   -8499.6189    294.41739    294.41739    23371.247    23371.247    925.49168    925.49168 
Loop time of 135.847 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.636 ns/day, 37.735 hours/ns, 7.361 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    | 135.27     | 135.27     | 135.27     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10528    | 0.10528    | 0.10528    |   0.0 |  0.08
Output  | 0.00015579 | 0.00015579 | 0.00015579 |   0.0 |  0.00
Modify  | 0.40819    | 0.40819    | 0.40819    |   0.0 |  0.30
Other   |            | 0.06372    |            |       |  0.05

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

Total # of neighbors = 128158
Ave neighs/atom = 64.079000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.759570541763, Press = -1.08549413214005
next a
jump SELF top
variable a loop 2000
run 1000
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   -8423.5441   -8423.5441   -8499.6189   -8499.6189    294.41739    294.41739    23371.247    23371.247    925.49168    925.49168 
   29000   -8428.6931   -8428.6931   -8502.4405   -8502.4405    285.41022    285.41022    23367.153    23367.153    605.38268    605.38268 
Loop time of 120.861 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.715 ns/day, 33.572 hours/ns, 8.274 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.36     | 120.36     | 120.36     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096143   | 0.096143   | 0.096143   |   0.0 |  0.08
Output  | 0.00019207 | 0.00019207 | 0.00019207 |   0.0 |  0.00
Modify  | 0.34946    | 0.34946    | 0.34946    |   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:      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 = 292.704529684086, Press = -0.218222312338762
next a
jump SELF top
variable a loop 2000
run 1000
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   -8428.6931   -8428.6931   -8502.4405   -8502.4405    285.41022    285.41022    23367.153    23367.153    605.38268    605.38268 
   30000   -8422.5888   -8422.5888   -8499.6126   -8499.6126    298.09006    298.09006     23366.94     23366.94    1310.5433    1310.5433 
Loop time of 120.857 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.715 ns/day, 33.571 hours/ns, 8.274 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.35     | 120.35     | 120.35     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09648    | 0.09648    | 0.09648    |   0.0 |  0.08
Output  | 0.00042185 | 0.00042185 | 0.00042185 |   0.0 |  0.00
Modify  | 0.34962    | 0.34962    | 0.34962    |   0.0 |  0.29
Other   |            | 0.05779    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.663794738471, Press = 0.312848875056955
next a
jump SELF top
variable a loop 2000
run 1000
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   -8422.5888   -8422.5888   -8499.6126   -8499.6126    298.09006    298.09006     23366.94     23366.94    1310.5433    1310.5433 
   31000    -8423.765    -8423.765   -8500.1982   -8500.1982    295.80435    295.80435    23341.086    23341.086    2941.7041    2941.7041 
Loop time of 120.942 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.595 hours/ns, 8.268 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.44     | 120.44     | 120.44     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096272   | 0.096272   | 0.096272   |   0.0 |  0.08
Output  | 0.00015455 | 0.00015455 | 0.00015455 |   0.0 |  0.00
Modify  | 0.35015    | 0.35015    | 0.35015    |   0.0 |  0.29
Other   |            | 0.0579     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.59483879193, Press = 0.765647825658632
next a
jump SELF top
variable a loop 2000
run 1000
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    -8423.765    -8423.765   -8500.1982   -8500.1982    295.80435    295.80435    23341.086    23341.086    2941.7041    2941.7041 
   32000   -8425.0571   -8425.0571     -8502.54     -8502.54    299.86684    299.86684    23326.486    23326.486    3797.8811    3797.8811 
Loop time of 120.794 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.715 ns/day, 33.554 hours/ns, 8.279 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.29     | 120.29     | 120.29     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096108   | 0.096108   | 0.096108   |   0.0 |  0.08
Output  | 0.00015478 | 0.00015478 | 0.00015478 |   0.0 |  0.00
Modify  | 0.349      | 0.349      | 0.349      |   0.0 |  0.29
Other   |            | 0.05784    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.526650868372, Press = 2.34379254206237
next a
jump SELF top
variable a loop 2000
run 1000
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   -8425.0571   -8425.0571     -8502.54     -8502.54    299.86684    299.86684    23326.486    23326.486    3797.8811    3797.8811 
   33000    -8426.237    -8426.237   -8501.0203   -8501.0203    289.41916    289.41916    23355.401    23355.401    1766.7216    1766.7216 
Loop time of 120.957 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.599 hours/ns, 8.267 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.45     | 120.45     | 120.45     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095608   | 0.095608   | 0.095608   |   0.0 |  0.08
Output  | 0.00015668 | 0.00015668 | 0.00015668 |   0.0 |  0.00
Modify  | 0.3499     | 0.3499     | 0.3499     |   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:      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 = 292.517069686169, Press = 2.49760024594386
next a
jump SELF top
variable a loop 2000
run 1000
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    -8426.237    -8426.237   -8501.0203   -8501.0203    289.41916    289.41916    23355.401    23355.401    1766.7216    1766.7216 
   34000   -8422.8713   -8422.8713   -8500.4659   -8500.4659     300.2991     300.2991    23382.733    23382.733    40.897241    40.897241 
Loop time of 120.93 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.592 hours/ns, 8.269 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.43     | 120.43     | 120.43     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095472   | 0.095472   | 0.095472   |   0.0 |  0.08
Output  | 0.00015403 | 0.00015403 | 0.00015403 |   0.0 |  0.00
Modify  | 0.34997    | 0.34997    | 0.34997    |   0.0 |  0.29
Other   |            | 0.05823    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.53596020808, Press = 2.92024944890956
next a
jump SELF top
variable a loop 2000
run 1000
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   -8422.8713   -8422.8713   -8500.4659   -8500.4659     300.2991     300.2991    23382.733    23382.733    40.897241    40.897241 
   35000   -8423.4748   -8423.4748   -8500.6568   -8500.6568    298.70232    298.70232    23404.243    23404.243   -1584.1855   -1584.1855 
Loop time of 121.002 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.612 hours/ns, 8.264 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.5      | 120.5      | 120.5      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095691   | 0.095691   | 0.095691   |   0.0 |  0.08
Output  | 0.00015524 | 0.00015524 | 0.00015524 |   0.0 |  0.00
Modify  | 0.34922    | 0.34922    | 0.34922    |   0.0 |  0.29
Other   |            | 0.05824    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.533663011323, Press = 2.19749040973883
next a
jump SELF top
variable a loop 2000
run 1000
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   -8423.4748   -8423.4748   -8500.6568   -8500.6568    298.70232    298.70232    23404.243    23404.243   -1584.1855   -1584.1855 
   36000   -8428.4828   -8428.4828   -8502.4743   -8502.4743    286.35505    286.35505    23402.988    23402.988   -1908.2653   -1908.2653 
Loop time of 120.713 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.716 ns/day, 33.531 hours/ns, 8.284 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.21     | 120.21     | 120.21     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095764   | 0.095764   | 0.095764   |   0.0 |  0.08
Output  | 0.00019812 | 0.00019812 | 0.00019812 |   0.0 |  0.00
Modify  | 0.3486     | 0.3486     | 0.3486     |   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:      128184.0 ave      128184 max      128184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128184
Ave neighs/atom = 64.092000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.507779178868, Press = 1.41359193940037
next a
jump SELF top
variable a loop 2000
run 1000
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   -8428.4828   -8428.4828   -8502.4743   -8502.4743    286.35505    286.35505    23402.988    23402.988   -1908.2653   -1908.2653 
   37000   -8423.9465   -8423.9465   -8499.6047   -8499.6047    292.80526    292.80526    23429.035    23429.035   -3295.6719   -3295.6719 
Loop time of 129.515 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.667 ns/day, 35.977 hours/ns, 7.721 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.97     | 128.97     | 128.97     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10044    | 0.10044    | 0.10044    |   0.0 |  0.08
Output  | 0.00015269 | 0.00015269 | 0.00015269 |   0.0 |  0.00
Modify  | 0.38754    | 0.38754    | 0.38754    |   0.0 |  0.30
Other   |            | 0.06103    |            |       |  0.05

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

Total # of neighbors = 128166
Ave neighs/atom = 64.083000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.456614294205, Press = 0.220602860440773
next a
jump SELF top
variable a loop 2000
run 1000
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   -8423.9465   -8423.9465   -8499.6047   -8499.6047    292.80526    292.80526    23429.035    23429.035   -3295.6719   -3295.6719 
   38000   -8429.0419   -8429.0419   -8501.4513   -8501.4513    280.23184    280.23184    23423.917    23423.917   -3349.8328   -3349.8328 
Loop time of 131.298 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.658 ns/day, 36.472 hours/ns, 7.616 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.74     | 130.74     | 130.74     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10374    | 0.10374    | 0.10374    |   0.0 |  0.08
Output  | 0.00015526 | 0.00015526 | 0.00015526 |   0.0 |  0.00
Modify  | 0.39548    | 0.39548    | 0.39548    |   0.0 |  0.30
Other   |            | 0.06193    |            |       |  0.05

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

Total # of neighbors = 128168
Ave neighs/atom = 64.084000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.426194577791, Press = -1.24035418169348
next a
jump SELF top
variable a loop 2000
run 1000
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   -8429.0419   -8429.0419   -8501.4513   -8501.4513    280.23184    280.23184    23423.917    23423.917   -3349.8328   -3349.8328 
   39000   -8424.0271   -8424.0271   -8498.3665   -8498.3665    287.70113    287.70113    23396.391    23396.391     -771.701     -771.701 
Loop time of 125.631 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.688 ns/day, 34.897 hours/ns, 7.960 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.1      | 125.1      | 125.1      |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098834   | 0.098834   | 0.098834   |   0.0 |  0.08
Output  | 0.00015393 | 0.00015393 | 0.00015393 |   0.0 |  0.00
Modify  | 0.37115    | 0.37115    | 0.37115    |   0.0 |  0.30
Other   |            | 0.06048    |            |       |  0.05

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

Total # of neighbors = 128198
Ave neighs/atom = 64.099000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.410392161665, Press = -0.304720772219644
next a
jump SELF top
variable a loop 2000
run 1000
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   -8424.0271   -8424.0271   -8498.3665   -8498.3665    287.70113    287.70113    23396.391    23396.391     -771.701     -771.701 
   40000   -8422.9878   -8422.9878   -8500.3588   -8500.3588    299.43389    299.43389    23391.719    23391.719   -693.86464   -693.86464 
Loop time of 138.106 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.626 ns/day, 38.363 hours/ns, 7.241 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.51     | 137.51     | 137.51     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10635    | 0.10635    | 0.10635    |   0.0 |  0.08
Output  | 0.00015959 | 0.00015959 | 0.00015959 |   0.0 |  0.00
Modify  | 0.42558    | 0.42558    | 0.42558    |   0.0 |  0.31
Other   |            | 0.06476    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.439099648411, Press = -0.324711372325321
next a
jump SELF top
variable a loop 2000
run 1000
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   -8422.9878   -8422.9878   -8500.3588   -8500.3588    299.43389    299.43389    23391.719    23391.719   -693.86464   -693.86464 
   41000   -8425.5627   -8425.5627   -8500.2412   -8500.2412    289.01329    289.01329    23374.237    23374.237    496.54806    496.54806 
Loop time of 120.872 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.715 ns/day, 33.576 hours/ns, 8.273 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.37     | 120.37     | 120.37     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095528   | 0.095528   | 0.095528   |   0.0 |  0.08
Output  | 0.00018837 | 0.00018837 | 0.00018837 |   0.0 |  0.00
Modify  | 0.35085    | 0.35085    | 0.35085    |   0.0 |  0.29
Other   |            | 0.0585     |            |       |  0.05

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

Total # of neighbors = 128170
Ave neighs/atom = 64.085000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.477004433563, Press = -0.451479567656752
next a
jump SELF top
variable a loop 2000
run 1000
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   -8425.5627   -8425.5627   -8500.2412   -8500.2412    289.01329    289.01329    23374.237    23374.237    496.54806    496.54806 
   42000   -8424.0182   -8424.0182     -8498.87     -8498.87    289.68403    289.68403    23355.214    23355.214    2069.5677    2069.5677 
Loop time of 120.673 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.716 ns/day, 33.520 hours/ns, 8.287 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.17     | 120.17     | 120.17     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095375   | 0.095375   | 0.095375   |   0.0 |  0.08
Output  | 0.00015785 | 0.00015785 | 0.00015785 |   0.0 |  0.00
Modify  | 0.35042    | 0.35042    | 0.35042    |   0.0 |  0.29
Other   |            | 0.05833    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.454347479611, Press = -0.629448516001215
next a
jump SELF top
variable a loop 2000
run 1000
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   -8424.0182   -8424.0182     -8498.87     -8498.87    289.68403    289.68403    23355.214    23355.214    2069.5677    2069.5677 
   43000   -8429.6895   -8429.6895   -8503.7758   -8503.7758     286.7214     286.7214    23347.206    23347.206    1981.0476    1981.0476 
Loop time of 120.914 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.715 ns/day, 33.587 hours/ns, 8.270 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.41     | 120.41     | 120.41     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094757   | 0.094757   | 0.094757   |   0.0 |  0.08
Output  | 0.00018565 | 0.00018565 | 0.00018565 |   0.0 |  0.00
Modify  | 0.35009    | 0.35009    | 0.35009    |   0.0 |  0.29
Other   |            | 0.05814    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.447129095852, Press = 0.22327535792194
next a
jump SELF top
variable a loop 2000
run 1000
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   -8429.6895   -8429.6895   -8503.7758   -8503.7758     286.7214     286.7214    23347.206    23347.206    1981.0476    1981.0476 
   44000   -8423.4787   -8423.4787   -8498.8186   -8498.8186    291.57343    291.57343    23369.866    23369.866    1052.2224    1052.2224 
Loop time of 120.708 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.716 ns/day, 33.530 hours/ns, 8.284 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.2      | 120.2      | 120.2      |   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.00015497 | 0.00015497 | 0.00015497 |   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:      128184.0 ave      128184 max      128184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128184
Ave neighs/atom = 64.092000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.420405359415, Press = 1.0482002016738
next a
jump SELF top
variable a loop 2000
run 1000
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   -8423.4787   -8423.4787   -8498.8186   -8498.8186    291.57343    291.57343    23369.866    23369.866    1052.2224    1052.2224 
   45000   -8422.0818   -8422.0818   -8499.3815   -8499.3815    299.15799    299.15799    23375.421    23375.421    685.71884    685.71884 
Loop time of 121.115 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.713 ns/day, 33.643 hours/ns, 8.257 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.096091   | 0.096091   | 0.096091   |   0.0 |  0.08
Output  | 0.00015396 | 0.00015396 | 0.00015396 |   0.0 |  0.00
Modify  | 0.34931    | 0.34931    | 0.34931    |   0.0 |  0.29
Other   |            | 0.05811    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.493090088475, Press = 0.879809113001403
next a
jump SELF top
variable a loop 2000
run 1000
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   -8422.0818   -8422.0818   -8499.3815   -8499.3815    299.15799    299.15799    23375.421    23375.421    685.71884    685.71884 
   46000   -8423.6577   -8423.6577   -8500.8672   -8500.8672    298.80881    298.80881    23379.381    23379.381    209.98459    209.98459 
Loop time of 133.378 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.648 ns/day, 37.049 hours/ns, 7.498 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.81     | 132.81     | 132.81     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10389    | 0.10389    | 0.10389    |   0.0 |  0.08
Output  | 0.00027551 | 0.00027551 | 0.00027551 |   0.0 |  0.00
Modify  | 0.40117    | 0.40117    | 0.40117    |   0.0 |  0.30
Other   |            | 0.0628     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.528418907175, Press = 1.51648292697978
next a
jump SELF top
variable a loop 2000
run 1000
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   -8423.6577   -8423.6577   -8500.8672   -8500.8672    298.80881    298.80881    23379.381    23379.381    209.98459    209.98459 
   47000   -8425.2718   -8425.2718    -8501.336    -8501.336    294.37614    294.37614    23396.839    23396.839   -1234.8715   -1234.8715 
Loop time of 138.404 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.624 ns/day, 38.445 hours/ns, 7.225 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.81     | 137.81     | 137.81     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10881    | 0.10881    | 0.10881    |   0.0 |  0.08
Output  | 0.00021456 | 0.00021456 | 0.00021456 |   0.0 |  0.00
Modify  | 0.42466    | 0.42466    | 0.42466    |   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:      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 = 292.561514233631, Press = 3.62598055688697
next a
jump SELF top
variable a loop 2000
run 1000
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   -8425.2718   -8425.2718    -8501.336    -8501.336    294.37614    294.37614    23396.839    23396.839   -1234.8715   -1234.8715 
   48000   -8422.5781   -8422.5781    -8500.347    -8500.347    300.97369    300.97369    23414.457    23414.457   -2213.8945   -2213.8945 
Loop time of 131.926 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.655 ns/day, 36.646 hours/ns, 7.580 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.36     | 131.36     | 131.36     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10383    | 0.10383    | 0.10383    |   0.0 |  0.08
Output  | 0.000192   | 0.000192   | 0.000192   |   0.0 |  0.00
Modify  | 0.40022    | 0.40022    | 0.40022    |   0.0 |  0.30
Other   |            | 0.06249    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.595586612938, Press = 2.5903848047382
next a
jump SELF top
variable a loop 2000
run 1000
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   -8422.5781   -8422.5781    -8500.347    -8500.347    300.97369    300.97369    23414.457    23414.457   -2213.8945   -2213.8945 
   49000   -8423.3831   -8423.3831   -8498.4837   -8498.4837    290.64738    290.64738    23403.008    23403.008   -1303.1221   -1303.1221 
Loop time of 121.266 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.712 ns/day, 33.685 hours/ns, 8.246 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.096787   | 0.096787   | 0.096787   |   0.0 |  0.08
Output  | 0.00015648 | 0.00015648 | 0.00015648 |   0.0 |  0.00
Modify  | 0.35333    | 0.35333    | 0.35333    |   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:      128118.0 ave      128118 max      128118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128118
Ave neighs/atom = 64.059000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.627096415734, Press = 1.40627021894101
next a
jump SELF top
variable a loop 2000
run 1000
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   -8423.3831   -8423.3831   -8498.4837   -8498.4837    290.64738    290.64738    23403.008    23403.008   -1303.1221   -1303.1221 
   50000   -8424.9926   -8424.9926   -8498.8793   -8498.8793    285.94931    285.94931    23392.723    23392.723   -608.07229   -608.07229 
Loop time of 121.078 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.714 ns/day, 33.633 hours/ns, 8.259 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.57     | 120.57     | 120.57     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096165   | 0.096165   | 0.096165   |   0.0 |  0.08
Output  | 0.00015315 | 0.00015315 | 0.00015315 |   0.0 |  0.00
Modify  | 0.35079    | 0.35079    | 0.35079    |   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:      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 = 292.710515900336, Press = 1.14811645329067
next a
jump SELF top
variable a loop 2000
run 1000
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   -8424.9926   -8424.9926   -8498.8793   -8498.8793    285.94931    285.94931    23392.723    23392.723   -608.07229   -608.07229 
   51000   -8425.1184   -8425.1184   -8499.5753   -8499.5753    288.15612    288.15612     23403.37     23403.37   -1504.3959   -1504.3959 
Loop time of 120.896 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.715 ns/day, 33.582 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.39     | 120.39     | 120.39     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095817   | 0.095817   | 0.095817   |   0.0 |  0.08
Output  | 0.00015344 | 0.00015344 | 0.00015344 |   0.0 |  0.00
Modify  | 0.35095    | 0.35095    | 0.35095    |   0.0 |  0.29
Other   |            | 0.0579     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.744681307493, Press = 0.654848938911024
next a
jump SELF top
variable a loop 2000
run 1000
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   -8425.1184   -8425.1184   -8499.5753   -8499.5753    288.15612    288.15612     23403.37     23403.37   -1504.3959   -1504.3959 
   52000   -8427.2569   -8427.2569   -8502.7809   -8502.7809    292.28586    292.28586    23426.608    23426.608   -3509.7866   -3509.7866 
Loop time of 126.95 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.681 ns/day, 35.264 hours/ns, 7.877 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.42     | 126.42     | 126.42     |   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.00015571 | 0.00015571 | 0.00015571 |   0.0 |  0.00
Modify  | 0.37224    | 0.37224    | 0.37224    |   0.0 |  0.29
Other   |            | 0.05966    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.767255073452, Press = -0.713025040482846
next a
jump SELF top
variable a loop 2000
run 1000
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   -8427.2569   -8427.2569   -8502.7809   -8502.7809    292.28586    292.28586    23426.608    23426.608   -3509.7866   -3509.7866 
   53000   -8423.7923   -8423.7923   -8498.8732   -8498.8732    290.57086    290.57086    23407.245    23407.245   -1596.0297   -1596.0297 
Loop time of 128.017 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.675 ns/day, 35.560 hours/ns, 7.811 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.47     | 127.47     | 127.47     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10124    | 0.10124    | 0.10124    |   0.0 |  0.08
Output  | 0.00020037 | 0.00020037 | 0.00020037 |   0.0 |  0.00
Modify  | 0.38121    | 0.38121    | 0.38121    |   0.0 |  0.30
Other   |            | 0.06086    |            |       |  0.05

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

Total # of neighbors = 128162
Ave neighs/atom = 64.081000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.730237340845, Press = -0.65871448630829
next a
jump SELF top
variable a loop 2000
run 1000
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   -8423.7923   -8423.7923   -8498.8732   -8498.8732    290.57086    290.57086    23407.245    23407.245   -1596.0297   -1596.0297 
   54000   -8427.5224   -8427.5224   -8502.0197   -8502.0197    288.31231    288.31231    23384.568    23384.568   -312.25104   -312.25104 
Loop time of 135.826 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.636 ns/day, 37.730 hours/ns, 7.362 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.24     | 135.24     | 135.24     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10619    | 0.10619    | 0.10619    |   0.0 |  0.08
Output  | 0.00020059 | 0.00020059 | 0.00020059 |   0.0 |  0.00
Modify  | 0.41554    | 0.41554    | 0.41554    |   0.0 |  0.31
Other   |            | 0.06439    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.709700871362, Press = -0.303762950073772
next a
jump SELF top
variable a loop 2000
run 1000
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   -8427.5224   -8427.5224   -8502.0197   -8502.0197    288.31231    288.31231    23384.568    23384.568   -312.25104   -312.25104 
   55000   -8424.7279   -8424.7279   -8500.0466   -8500.0466    291.49121    291.49121    23372.833    23372.833    716.60869    716.60869 
Loop time of 132.167 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.654 ns/day, 36.713 hours/ns, 7.566 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.6      | 131.6      | 131.6      |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10489    | 0.10489    | 0.10489    |   0.0 |  0.08
Output  | 0.00015408 | 0.00015408 | 0.00015408 |   0.0 |  0.00
Modify  | 0.39834    | 0.39834    | 0.39834    |   0.0 |  0.30
Other   |            | 0.06205    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.666456732948, Press = -0.112448974023293
next a
jump SELF top
variable a loop 2000
run 1000
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   -8424.7279   -8424.7279   -8500.0466   -8500.0466    291.49121    291.49121    23372.833    23372.833    716.60869    716.60869 
   56000   -8426.5751   -8426.5751   -8500.6207   -8500.6207    286.56399    286.56399    23360.026    23360.026    1536.7912    1536.7912 
Loop time of 120.765 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.715 ns/day, 33.546 hours/ns, 8.281 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.26     | 120.26     | 120.26     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096754   | 0.096754   | 0.096754   |   0.0 |  0.08
Output  | 0.00015754 | 0.00015754 | 0.00015754 |   0.0 |  0.00
Modify  | 0.35197    | 0.35197    | 0.35197    |   0.0 |  0.29
Other   |            | 0.0586     |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.673771223585, Press = -0.0722584889028734
next a
jump SELF top
variable a loop 2000
run 1000
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   -8426.5751   -8426.5751   -8500.6207   -8500.6207    286.56399    286.56399    23360.026    23360.026    1536.7912    1536.7912 
   57000   -8423.5359   -8423.5359   -8502.3515   -8502.3515    305.02459    305.02459    23368.178    23368.178    776.37542    776.37542 
Loop time of 120.683 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.716 ns/day, 33.523 hours/ns, 8.286 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.18     | 120.18     | 120.18     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096215   | 0.096215   | 0.096215   |   0.0 |  0.08
Output  | 0.00015523 | 0.00015523 | 0.00015523 |   0.0 |  0.00
Modify  | 0.35174    | 0.35174    | 0.35174    |   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:      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 = 292.627927600742, Press = 0.352981106079973
next a
jump SELF top
variable a loop 2000
run 1000
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   -8423.5359   -8423.5359   -8502.3515   -8502.3515    305.02459    305.02459    23368.178    23368.178    776.37542    776.37542 
   58000   -8425.9525   -8425.9525   -8502.1548   -8502.1548    294.91048    294.91048    23367.971    23367.971    635.06664    635.06664 
Loop time of 128.388 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.673 ns/day, 35.663 hours/ns, 7.789 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.84     | 127.84     | 127.84     |   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.00015303 | 0.00015303 | 0.00015303 |   0.0 |  0.00
Modify  | 0.37966    | 0.37966    | 0.37966    |   0.0 |  0.30
Other   |            | 0.06174    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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 = 292.648740284776, Press = 0.892080213787186
next a
jump SELF top
variable a loop 2000
run 1000
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   -8425.9525   -8425.9525   -8502.1548   -8502.1548    294.91048    294.91048    23367.971    23367.971    635.06664    635.06664 
   59000    -8423.841    -8423.841   -8499.8709   -8499.8709    294.24377    294.24377    23365.281    23365.281    1321.7856    1321.7856 
Loop time of 124.2 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.696 ns/day, 34.500 hours/ns, 8.052 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.68     | 123.68     | 123.68     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098126   | 0.098126   | 0.098126   |   0.0 |  0.08
Output  | 0.00015705 | 0.00015705 | 0.00015705 |   0.0 |  0.00
Modify  | 0.36563    | 0.36563    | 0.36563    |   0.0 |  0.29
Other   |            | 0.06108    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.704988971252, Press = 1.0197801042459
next a
jump SELF top
variable a loop 2000
run 1000
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    -8423.841    -8423.841   -8499.8709   -8499.8709    294.24377    294.24377    23365.281    23365.281    1321.7856    1321.7856 
   60000   -8425.0369   -8425.0369   -8499.0228   -8499.0228    286.33302    286.33302    23352.689    23352.689    2240.6129    2240.6129 
Loop time of 129.29 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128.74     | 128.74     | 128.74     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10191    | 0.10191    | 0.10191    |   0.0 |  0.08
Output  | 0.00019828 | 0.00019828 | 0.00019828 |   0.0 |  0.00
Modify  | 0.38697    | 0.38697    | 0.38697    |   0.0 |  0.30
Other   |            | 0.06149    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.738522624785, Press = 1.29782947676176
next a
jump SELF top
variable a loop 2000
run 1000
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   -8425.0369   -8425.0369   -8499.0228   -8499.0228    286.33302    286.33302    23352.689    23352.689    2240.6129    2240.6129 
   61000   -8423.8196   -8423.8196   -8499.3074   -8499.3074    292.14577    292.14577    23348.811    23348.811    2646.4771    2646.4771 
Loop time of 120.662 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.716 ns/day, 33.517 hours/ns, 8.288 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.16     | 120.16     | 120.16     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096656   | 0.096656   | 0.096656   |   0.0 |  0.08
Output  | 0.00015542 | 0.00015542 | 0.00015542 |   0.0 |  0.00
Modify  | 0.3508     | 0.3508     | 0.3508     |   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:      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 = 292.778555183264, Press = 2.73880814549842
next a
jump SELF top
variable a loop 2000
run 1000
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   -8423.8196   -8423.8196   -8499.3074   -8499.3074    292.14577    292.14577    23348.811    23348.811    2646.4771    2646.4771 
   62000   -8421.2201   -8421.2201   -8499.0323   -8499.0323    301.14148    301.14148    23386.174    23386.174   -20.805487   -20.805487 
Loop time of 120.747 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.716 ns/day, 33.541 hours/ns, 8.282 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.24     | 120.24     | 120.24     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096646   | 0.096646   | 0.096646   |   0.0 |  0.08
Output  | 0.00015277 | 0.00015277 | 0.00015277 |   0.0 |  0.00
Modify  | 0.35051    | 0.35051    | 0.35051    |   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:      128264.0 ave      128264 max      128264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128264
Ave neighs/atom = 64.132000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.773435027406, Press = 2.12102340196811
next a
jump SELF top
variable a loop 2000
run 1000
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   -8421.2201   -8421.2201   -8499.0323   -8499.0323    301.14148    301.14148    23386.174    23386.174   -20.805487   -20.805487 
   63000   -8425.8724   -8425.8724   -8499.9833   -8499.9833    286.81662    286.81662    23387.359    23387.359   -433.69858   -433.69858 
Loop time of 122.306 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.706 ns/day, 33.974 hours/ns, 8.176 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 121.79     | 121.79     | 121.79     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097949   | 0.097949   | 0.097949   |   0.0 |  0.08
Output  | 0.00015611 | 0.00015611 | 0.00015611 |   0.0 |  0.00
Modify  | 0.3562     | 0.3562     | 0.3562     |   0.0 |  0.29
Other   |            | 0.05937    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.802281256561, Press = 1.69520026699953
next a
jump SELF top
variable a loop 2000
run 1000
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   -8425.8724   -8425.8724   -8499.9833   -8499.9833    286.81662    286.81662    23387.359    23387.359   -433.69858   -433.69858 
   64000   -8420.9353   -8420.9353   -8498.9307   -8498.9307    301.85022    301.85022    23398.753    23398.753   -839.65208   -839.65208 
Loop time of 121.385 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.712 ns/day, 33.718 hours/ns, 8.238 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.88     | 120.88     | 120.88     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097588   | 0.097588   | 0.097588   |   0.0 |  0.08
Output  | 0.00018813 | 0.00018813 | 0.00018813 |   0.0 |  0.00
Modify  | 0.35228    | 0.35228    | 0.35228    |   0.0 |  0.29
Other   |            | 0.05916    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.857589581335, Press = 1.4116618256709
next a
jump SELF top
variable a loop 2000
run 1000
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   -8420.9353   -8420.9353   -8498.9307   -8498.9307    301.85022    301.85022    23398.753    23398.753   -839.65208   -839.65208 
   65000   -8426.2397   -8426.2397   -8501.6202   -8501.6202    291.73046    291.73046    23409.544    23409.544   -2212.3133   -2212.3133 
Loop time of 134.29 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.643 ns/day, 37.303 hours/ns, 7.447 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.72     | 133.72     | 133.72     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10461    | 0.10461    | 0.10461    |   0.0 |  0.08
Output  | 0.00019129 | 0.00019129 | 0.00019129 |   0.0 |  0.00
Modify  | 0.4058     | 0.4058     | 0.4058     |   0.0 |  0.30
Other   |            | 0.06336    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.873997669601, Press = 1.08754230914562
next a
jump SELF top
variable a loop 2000
run 1000
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   -8426.2397   -8426.2397   -8501.6202   -8501.6202    291.73046    291.73046    23409.544    23409.544   -2212.3133   -2212.3133 
   66000   -8421.6584   -8421.6584   -8498.3587   -8498.3587    296.83812    296.83812    23433.874    23433.874   -3498.6951   -3498.6951 
Loop time of 141.108 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.612 ns/day, 39.197 hours/ns, 7.087 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    | 140.49     | 140.49     | 140.49     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10941    | 0.10941    | 0.10941    |   0.0 |  0.08
Output  | 0.00015302 | 0.00015302 | 0.00015302 |   0.0 |  0.00
Modify  | 0.43861    | 0.43861    | 0.43861    |   0.0 |  0.31
Other   |            | 0.06601    |            |       |  0.05

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

Total # of neighbors = 128158
Ave neighs/atom = 64.079000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.913737758455, Press = 0.359878621914995
next a
jump SELF top
variable a loop 2000
run 1000
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   -8421.6584   -8421.6584   -8498.3587   -8498.3587    296.83812    296.83812    23433.874    23433.874   -3498.6951   -3498.6951 
   67000   -8422.6041   -8422.6041   -8499.8407   -8499.8407    298.91393    298.91393    23425.202    23425.202   -2894.3943   -2894.3943 
Loop time of 134.211 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.644 ns/day, 37.281 hours/ns, 7.451 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.64     | 133.64     | 133.64     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10478    | 0.10478    | 0.10478    |   0.0 |  0.08
Output  | 0.00015646 | 0.00015646 | 0.00015646 |   0.0 |  0.00
Modify  | 0.40717    | 0.40717    | 0.40717    |   0.0 |  0.30
Other   |            | 0.06235    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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 = 292.926558160882, Press = -0.506574488624023
next a
jump SELF top
variable a loop 2000
run 1000
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   -8422.6041   -8422.6041   -8499.8407   -8499.8407    298.91393    298.91393    23425.202    23425.202   -2894.3943   -2894.3943 
   68000   -8427.6562   -8427.6562   -8502.4728   -8502.4728    289.54805    289.54805    23383.649    23383.649   -387.40695   -387.40695 
Loop time of 121.978 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.708 ns/day, 33.883 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.097074   | 0.097074   | 0.097074   |   0.0 |  0.08
Output  | 0.00015523 | 0.00015523 | 0.00015523 |   0.0 |  0.00
Modify  | 0.35486    | 0.35486    | 0.35486    |   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:      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 = 292.896591556458, Press = 0.119548631171096
next a
jump SELF top
variable a loop 2000
run 1000
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   -8427.6562   -8427.6562   -8502.4728   -8502.4728    289.54805    289.54805    23383.649    23383.649   -387.40695   -387.40695 
   69000   -8422.5885   -8422.5885   -8498.2664   -8498.2664    292.88138    292.88138    23382.873    23382.873    174.53518    174.53518 
Loop time of 141.087 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.612 ns/day, 39.191 hours/ns, 7.088 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.48     | 140.48     | 140.48     |   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.00015443 | 0.00015443 | 0.00015443 |   0.0 |  0.00
Modify  | 0.43666    | 0.43666    | 0.43666    |   0.0 |  0.31
Other   |            | 0.06615    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      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 = 292.896873445371, Press = 0.405199217495474
next a
jump SELF top
variable a loop 2000
run 1000
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   -8422.5885   -8422.5885   -8498.2664   -8498.2664    292.88138    292.88138    23382.873    23382.873    174.53518    174.53518 
   70000   -8426.3987   -8426.3987   -8500.9961   -8500.9961    288.69993    288.69993    23378.577    23378.577    116.22958    116.22958 
Loop time of 133.142 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.649 ns/day, 36.984 hours/ns, 7.511 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.57     | 132.57     | 132.57     |   0.0 | 99.57
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10394    | 0.10394    | 0.10394    |   0.0 |  0.08
Output  | 0.00025539 | 0.00025539 | 0.00025539 |   0.0 |  0.00
Modify  | 0.40382    | 0.40382    | 0.40382    |   0.0 |  0.30
Other   |            | 0.06271    |            |       |  0.05

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

Total # of neighbors = 128198
Ave neighs/atom = 64.099000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.914751687836, Press = 0.498895578054668
next a
jump SELF top
variable a loop 2000
run 1000
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   -8426.3987   -8426.3987   -8500.9961   -8500.9961    288.69993    288.69993    23378.577    23378.577    116.22958    116.22958 
   71000   -8423.3757   -8423.3757   -8499.5874   -8499.5874    294.94721    294.94721    23383.216    23383.216    70.137543    70.137543 
Loop time of 125.772 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.687 ns/day, 34.937 hours/ns, 7.951 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    | 125.24     | 125.24     | 125.24     |   0.0 | 99.58
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099673   | 0.099673   | 0.099673   |   0.0 |  0.08
Output  | 0.00047763 | 0.00047763 | 0.00047763 |   0.0 |  0.00
Modify  | 0.37208    | 0.37208    | 0.37208    |   0.0 |  0.30
Other   |            | 0.06057    |            |       |  0.05

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 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"
jump SELF break

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0