# 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.8809778466820717*${_u_distance}
variable latticeconst_converted equal 2.8809778466820717*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.88097784668207
Lattice spacing in x,y,z = 2.8809778 2.8809778 2.8809778
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.809778 28.809778 28.809778)
  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.809778 28.809778 28.809778)
  create_atoms CPU = 0.004 seconds

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

kim_interactions Cr

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

kim interactions Cr
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_LeeBaskesKim_2001_Cr__MO_134550636109_000
pair_coeff * * Cr
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 51.9961

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_134550636109_000#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -8119.0848   -8119.0848        -8200        -8200       313.15       313.15    23912.212    23912.212    3614.3322    3614.3322 
    1000   -8031.4482   -8031.4482   -8116.2855   -8116.2855    328.32891    328.32891    24096.422    24096.422    294.28772    294.28772 
Loop time of 97.8912 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.388     | 97.388     | 97.388     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079859   | 0.079859   | 0.079859   |   0.0 |  0.08
Output  | 0.00020356 | 0.00020356 | 0.00020356 |   0.0 |  0.00
Modify  | 0.36419    | 0.36419    | 0.36419    |   0.0 |  0.37
Other   |            | 0.0591     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116000.0 ave      116000 max      116000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116000
Ave neighs/atom = 58.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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -8031.4482   -8031.4482   -8116.2855   -8116.2855    328.32891    328.32891    24096.422    24096.422    294.28772    294.28772 
    2000   -8033.3256   -8033.3256   -8111.5068   -8111.5068    302.56914    302.56914     24120.17     24120.17   -1646.1729   -1646.1729 
Loop time of 99.5797 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.661 hours/ns, 10.042 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    | 99.096     | 99.096     | 99.096     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076026   | 0.076026   | 0.076026   |   0.0 |  0.08
Output  | 0.00019316 | 0.00019316 | 0.00019316 |   0.0 |  0.00
Modify  | 0.34941    | 0.34941    | 0.34941    |   0.0 |  0.35
Other   |            | 0.05784    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2949.00 ave        2949 max        2949 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116192.0 ave      116192 max      116192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116192
Ave neighs/atom = 58.096000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -8033.3256   -8033.3256   -8111.5068   -8111.5068    302.56914    302.56914     24120.17     24120.17   -1646.1729   -1646.1729 
    3000   -8033.4728   -8033.4728   -8111.9074   -8111.9074    303.55003    303.55003    24104.445    24104.445   -354.90838   -354.90838 
Loop time of 100.048 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.864 ns/day, 27.791 hours/ns, 9.995 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    | 99.564     | 99.564     | 99.564     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075812   | 0.075812   | 0.075812   |   0.0 |  0.08
Output  | 0.00018878 | 0.00018878 | 0.00018878 |   0.0 |  0.00
Modify  | 0.35052    | 0.35052    | 0.35052    |   0.0 |  0.35
Other   |            | 0.05721    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2947.00 ave        2947 max        2947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116274.0 ave      116274 max      116274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116274
Ave neighs/atom = 58.137000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8033.4728   -8033.4728   -8111.9074   -8111.9074    303.55003    303.55003    24104.445    24104.445   -354.90838   -354.90838 
    4000    -8032.231    -8032.231   -8115.0644   -8115.0644    320.57394    320.57394    24071.012    24071.012    1979.3961    1979.3961 
Loop time of 99.0996 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.528 hours/ns, 10.091 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.619     | 98.619     | 98.619     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074668   | 0.074668   | 0.074668   |   0.0 |  0.08
Output  | 0.00018675 | 0.00018675 | 0.00018675 |   0.0 |  0.00
Modify  | 0.34811    | 0.34811    | 0.34811    |   0.0 |  0.35
Other   |            | 0.05712    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2943.00 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116240.0 ave      116240 max      116240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116240
Ave neighs/atom = 58.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 = 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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000    -8032.231    -8032.231   -8115.0644   -8115.0644    320.57394    320.57394    24071.012    24071.012    1979.3961    1979.3961 
    5000   -8033.9861   -8033.9861   -8114.1873   -8114.1873    310.38708    310.38708    24080.433    24080.433    1502.5639    1502.5639 
Loop time of 98.886 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.468 hours/ns, 10.113 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.404     | 98.404     | 98.404     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075282   | 0.075282   | 0.075282   |   0.0 |  0.08
Output  | 0.00018448 | 0.00018448 | 0.00018448 |   0.0 |  0.00
Modify  | 0.34899    | 0.34899    | 0.34899    |   0.0 |  0.35
Other   |            | 0.05717    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2944.00 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116270.0 ave      116270 max      116270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116270
Ave neighs/atom = 58.135000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 310.505877160689, Press = 2108.16093035447
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8033.9861   -8033.9861   -8114.1873   -8114.1873    310.38708    310.38708    24080.433    24080.433    1502.5639    1502.5639 
    6000   -8031.9152   -8031.9152   -8113.6606   -8113.6606    316.36348    316.36348    24138.155    24138.155   -2982.8726   -2982.8726 
Loop time of 99.7341 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.866 ns/day, 27.704 hours/ns, 10.027 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    | 99.231     | 99.231     | 99.231     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075614   | 0.075614   | 0.075614   |   0.0 |  0.08
Output  | 0.0001579  | 0.0001579  | 0.0001579  |   0.0 |  0.00
Modify  | 0.36979    | 0.36979    | 0.36979    |   0.0 |  0.37
Other   |            | 0.0576     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2944.00 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116254.0 ave      116254 max      116254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116254
Ave neighs/atom = 58.127000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.328116610787, Press = 91.294092173719
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -8031.9152   -8031.9152   -8113.6606   -8113.6606    316.36348    316.36348    24138.155    24138.155   -2982.8726   -2982.8726 
    7000   -8036.7364   -8036.7364   -8116.0932   -8116.0932    307.11914    307.11914    24100.523    24100.523   -562.04393   -562.04393 
Loop time of 101.752 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.849 ns/day, 28.265 hours/ns, 9.828 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    | 101.23     | 101.23     | 101.23     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077326   | 0.077326   | 0.077326   |   0.0 |  0.08
Output  | 0.00015412 | 0.00015412 | 0.00015412 |   0.0 |  0.00
Modify  | 0.38271    | 0.38271    | 0.38271    |   0.0 |  0.38
Other   |            | 0.05871    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2943.00 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116224.0 ave      116224 max      116224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116224
Ave neighs/atom = 58.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 = 311.819937073416, Press = 9.26497083001646
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8036.7364   -8036.7364   -8116.0932   -8116.0932    307.11914    307.11914    24100.523    24100.523   -562.04393   -562.04393 
    8000    -8031.483    -8031.483   -8112.8135   -8112.8135    314.75727    314.75727    24073.359    24073.359    1954.9681    1954.9681 
Loop time of 100.218 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.862 ns/day, 27.838 hours/ns, 9.978 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    | 99.71      | 99.71      | 99.71      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076181   | 0.076181   | 0.076181   |   0.0 |  0.08
Output  | 0.00023935 | 0.00023935 | 0.00023935 |   0.0 |  0.00
Modify  | 0.37397    | 0.37397    | 0.37397    |   0.0 |  0.37
Other   |            | 0.05785    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2947.00 ave        2947 max        2947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116194.0 ave      116194 max      116194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116194
Ave neighs/atom = 58.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 = 311.748302930454, Press = 27.3773518046993
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000    -8031.483    -8031.483   -8112.8135   -8112.8135    314.75727    314.75727    24073.359    24073.359    1954.9681    1954.9681 
    9000    -8035.299    -8035.299   -8116.2316   -8116.2316    313.21781    313.21781    24095.235    24095.235   -77.446305   -77.446305 
Loop time of 101.01 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.855 ns/day, 28.058 hours/ns, 9.900 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    | 100.5      | 100.5      | 100.5      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077081   | 0.077081   | 0.077081   |   0.0 |  0.08
Output  | 0.00015699 | 0.00015699 | 0.00015699 |   0.0 |  0.00
Modify  | 0.37896    | 0.37896    | 0.37896    |   0.0 |  0.38
Other   |            | 0.05819    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2944.00 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116226.0 ave      116226 max      116226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116226
Ave neighs/atom = 58.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 = 311.639019346246, Press = 34.4665166295099
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000    -8035.299    -8035.299   -8116.2316   -8116.2316    313.21781    313.21781    24095.235    24095.235   -77.446305   -77.446305 
   10000   -8032.9393   -8032.9393   -8114.0123   -8114.0123    313.76081    313.76081    24141.973    24141.973   -3210.9753   -3210.9753 
Loop time of 101.208 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.854 ns/day, 28.113 hours/ns, 9.881 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    | 100.7      | 100.7      | 100.7      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077318   | 0.077318   | 0.077318   |   0.0 |  0.08
Output  | 0.00015588 | 0.00015588 | 0.00015588 |   0.0 |  0.00
Modify  | 0.3756     | 0.3756     | 0.3756     |   0.0 |  0.37
Other   |            | 0.05832    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2942.00 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116218.0 ave      116218 max      116218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116218
Ave neighs/atom = 58.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 = 311.407493520582, Press = 13.6423765111445
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8032.9393   -8032.9393   -8114.0123   -8114.0123    313.76081    313.76081    24141.973    24141.973   -3210.9753   -3210.9753 
   11000   -8030.5082   -8030.5082   -8112.6297   -8112.6297    317.81835    317.81835    24099.059    24099.059    134.34911    134.34911 
Loop time of 102.573 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.842 ns/day, 28.492 hours/ns, 9.749 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    | 102.05     | 102.05     | 102.05     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077226   | 0.077226   | 0.077226   |   0.0 |  0.08
Output  | 0.00015545 | 0.00015545 | 0.00015545 |   0.0 |  0.00
Modify  | 0.38556    | 0.38556    | 0.38556    |   0.0 |  0.38
Other   |            | 0.05872    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116202.0 ave      116202 max      116202 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116202
Ave neighs/atom = 58.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 = 311.562995561874, Press = -3.6140110246105
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8030.5082   -8030.5082   -8112.6297   -8112.6297    317.81835    317.81835    24099.059    24099.059    134.34911    134.34911 
   12000   -8033.0006   -8033.0006   -8111.6274   -8111.6274    304.29395    304.29395    24067.304    24067.304    2547.4018    2547.4018 
Loop time of 99.3713 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.868     | 98.868     | 98.868     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075585   | 0.075585   | 0.075585   |   0.0 |  0.08
Output  | 0.00019786 | 0.00019786 | 0.00019786 |   0.0 |  0.00
Modify  | 0.36976    | 0.36976    | 0.36976    |   0.0 |  0.37
Other   |            | 0.05765    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2945.00 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116224.0 ave      116224 max      116224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116224
Ave neighs/atom = 58.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 = 312.299188210786, Press = 13.7283839730299
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8033.0006   -8033.0006   -8111.6274   -8111.6274    304.29395    304.29395    24067.304    24067.304    2547.4018    2547.4018 
   13000    -8031.861    -8031.861   -8111.3967   -8111.3967    307.81112    307.81112    24100.377    24100.377    66.696328    66.696328 
Loop time of 101.495 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.851 ns/day, 28.193 hours/ns, 9.853 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    | 100.98     | 100.98     | 100.98     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076456   | 0.076456   | 0.076456   |   0.0 |  0.08
Output  | 0.00015714 | 0.00015714 | 0.00015714 |   0.0 |  0.00
Modify  | 0.37985    | 0.37985    | 0.37985    |   0.0 |  0.37
Other   |            | 0.05871    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2945.00 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116240.0 ave      116240 max      116240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116240
Ave neighs/atom = 58.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 = 312.508922911309, Press = 16.1452578051109
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000    -8031.861    -8031.861   -8111.3967   -8111.3967    307.81112    307.81112    24100.377    24100.377    66.696328    66.696328 
   14000   -8033.4029   -8033.4029   -8113.4616   -8113.4616    309.83533    309.83533    24117.172    24117.172   -1409.1841   -1409.1841 
Loop time of 102.587 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.842 ns/day, 28.496 hours/ns, 9.748 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    | 102.06     | 102.06     | 102.06     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078002   | 0.078002   | 0.078002   |   0.0 |  0.08
Output  | 0.00023966 | 0.00023966 | 0.00023966 |   0.0 |  0.00
Modify  | 0.38481    | 0.38481    | 0.38481    |   0.0 |  0.38
Other   |            | 0.05887    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116260.0 ave      116260 max      116260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116260
Ave neighs/atom = 58.130000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.64855365488, Press = 7.04070979601401
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8033.4029   -8033.4029   -8113.4616   -8113.4616    309.83533    309.83533    24117.172    24117.172   -1409.1841   -1409.1841 
   15000    -8031.628    -8031.628   -8112.2718   -8112.2718    312.09983    312.09983    24087.353    24087.353      1090.03      1090.03 
Loop time of 100.162 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.863 ns/day, 27.823 hours/ns, 9.984 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    | 99.656     | 99.656     | 99.656     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076225   | 0.076225   | 0.076225   |   0.0 |  0.08
Output  | 0.00047361 | 0.00047361 | 0.00047361 |   0.0 |  0.00
Modify  | 0.37108    | 0.37108    | 0.37108    |   0.0 |  0.37
Other   |            | 0.05794    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2943.00 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116210.0 ave      116210 max      116210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116210
Ave neighs/atom = 58.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 = 312.597967231223, Press = 4.88950717510629
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000    -8031.628    -8031.628   -8112.2718   -8112.2718    312.09983    312.09983    24087.353    24087.353      1090.03      1090.03 
   16000   -8035.8047   -8035.8047   -8115.8559   -8115.8559     309.8065     309.8065    24029.849    24029.849    5007.8885    5007.8885 
Loop time of 99.9169 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.865 ns/day, 27.755 hours/ns, 10.008 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    | 99.413     | 99.413     | 99.413     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076071   | 0.076071   | 0.076071   |   0.0 |  0.08
Output  | 0.00015607 | 0.00015607 | 0.00015607 |   0.0 |  0.00
Modify  | 0.36971    | 0.36971    | 0.36971    |   0.0 |  0.37
Other   |            | 0.05786    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2942.00 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116230.0 ave      116230 max      116230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116230
Ave neighs/atom = 58.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 = 312.542901482534, Press = 15.7621376989302
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8035.8047   -8035.8047   -8115.8559   -8115.8559     309.8065     309.8065    24029.849    24029.849    5007.8885    5007.8885 
   17000   -8033.6596   -8033.6596   -8115.0596   -8115.0596    315.02631    315.02631    24124.069    24124.069   -2042.6611   -2042.6611 
Loop time of 100.964 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.856 ns/day, 28.046 hours/ns, 9.904 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    | 100.45     | 100.45     | 100.45     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076218   | 0.076218   | 0.076218   |   0.0 |  0.08
Output  | 0.00015487 | 0.00015487 | 0.00015487 |   0.0 |  0.00
Modify  | 0.3757     | 0.3757     | 0.3757     |   0.0 |  0.37
Other   |            | 0.05789    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2942.00 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116262.0 ave      116262 max      116262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116262
Ave neighs/atom = 58.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 = 312.335360460688, Press = 13.0104092237923
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8033.6596   -8033.6596   -8115.0596   -8115.0596    315.02631    315.02631    24124.069    24124.069   -2042.6611   -2042.6611 
   18000   -8032.5671   -8032.5671   -8112.8727   -8112.8727    310.79107    310.79107    24122.765    24122.765   -1732.0793   -1732.0793 
Loop time of 99.4465 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.946     | 98.946     | 98.946     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075127   | 0.075127   | 0.075127   |   0.0 |  0.08
Output  | 0.0001516  | 0.0001516  | 0.0001516  |   0.0 |  0.00
Modify  | 0.3676     | 0.3676     | 0.3676     |   0.0 |  0.37
Other   |            | 0.05768    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2945.00 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116180.0 ave      116180 max      116180 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116180
Ave neighs/atom = 58.090000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.45628099361, Press = 3.43635468528892
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8032.5671   -8032.5671   -8112.8727   -8112.8727    310.79107    310.79107    24122.765    24122.765   -1732.0793   -1732.0793 
   19000   -8036.7768   -8036.7768   -8116.2029   -8116.2029    307.38708    307.38708    24076.063    24076.063    1425.5029    1425.5029 
Loop time of 99.4792 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.975     | 98.975     | 98.975     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076191   | 0.076191   | 0.076191   |   0.0 |  0.08
Output  | 0.0001543  | 0.0001543  | 0.0001543  |   0.0 |  0.00
Modify  | 0.37069    | 0.37069    | 0.37069    |   0.0 |  0.37
Other   |            | 0.05747    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2945.00 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116214.0 ave      116214 max      116214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116214
Ave neighs/atom = 58.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 = 312.279452582281, Press = 3.97995610704409
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8036.7768   -8036.7768   -8116.2029   -8116.2029    307.38708    307.38708    24076.063    24076.063    1425.5029    1425.5029 
   20000   -8033.3491   -8033.3491     -8114.07     -8114.07     312.3982     312.3982    24080.626    24080.626    1462.2598    1462.2598 
Loop time of 100.332 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.861 ns/day, 27.870 hours/ns, 9.967 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    | 99.826     | 99.826     | 99.826     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076543   | 0.076543   | 0.076543   |   0.0 |  0.08
Output  | 0.00014926 | 0.00014926 | 0.00014926 |   0.0 |  0.00
Modify  | 0.37115    | 0.37115    | 0.37115    |   0.0 |  0.37
Other   |            | 0.05787    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116232.0 ave      116232 max      116232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116232
Ave neighs/atom = 58.116000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.329485602014, Press = 8.40201555665499
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8033.3491   -8033.3491     -8114.07     -8114.07     312.3982     312.3982    24080.626    24080.626    1462.2598    1462.2598 
   21000   -8033.3262   -8033.3262   -8114.7073   -8114.7073    314.95302    314.95302    24137.653    24137.653   -3119.0047   -3119.0047 
Loop time of 99.9546 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.864 ns/day, 27.765 hours/ns, 10.005 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    | 99.445     | 99.445     | 99.445     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076749   | 0.076749   | 0.076749   |   0.0 |  0.08
Output  | 0.00015465 | 0.00015465 | 0.00015465 |   0.0 |  0.00
Modify  | 0.37483    | 0.37483    | 0.37483    |   0.0 |  0.38
Other   |            | 0.05774    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2945.00 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116230.0 ave      116230 max      116230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116230
Ave neighs/atom = 58.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 = 312.306366187247, Press = 9.21542900120601
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8033.3262   -8033.3262   -8114.7073   -8114.7073    314.95302    314.95302    24137.653    24137.653   -3119.0047   -3119.0047 
   22000   -8034.0292   -8034.0292   -8112.5653   -8112.5653    303.94272    303.94272    24133.649    24133.649    -2557.531    -2557.531 
Loop time of 100.698 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.858 ns/day, 27.972 hours/ns, 9.931 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    | 100.19     | 100.19     | 100.19     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076242   | 0.076242   | 0.076242   |   0.0 |  0.08
Output  | 0.00015367 | 0.00015367 | 0.00015367 |   0.0 |  0.00
Modify  | 0.37486    | 0.37486    | 0.37486    |   0.0 |  0.37
Other   |            | 0.05863    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116184.0 ave      116184 max      116184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116184
Ave neighs/atom = 58.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 = 312.371623464695, Press = 0.156097176680451
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8034.0292   -8034.0292   -8112.5653   -8112.5653    303.94272    303.94272    24133.649    24133.649    -2557.531    -2557.531 
   23000   -8035.2132   -8035.2132   -8115.0761   -8115.0761    309.07783    309.07783    24078.943    24078.943    1349.1555    1349.1555 
Loop time of 101.484 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.851 ns/day, 28.190 hours/ns, 9.854 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    | 100.97     | 100.97     | 100.97     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076835   | 0.076835   | 0.076835   |   0.0 |  0.08
Output  | 0.00019846 | 0.00019846 | 0.00019846 |   0.0 |  0.00
Modify  | 0.38028    | 0.38028    | 0.38028    |   0.0 |  0.37
Other   |            | 0.05886    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2942.00 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116208.0 ave      116208 max      116208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116208
Ave neighs/atom = 58.104000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.420673977602, Press = 3.43753878798603
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8035.2132   -8035.2132   -8115.0761   -8115.0761    309.07783    309.07783    24078.943    24078.943    1349.1555    1349.1555 
   24000   -8030.2157   -8030.2157    -8113.815    -8113.815    323.53803    323.53803    24089.563    24089.563    876.24889    876.24889 
Loop time of 99.6881 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.867 ns/day, 27.691 hours/ns, 10.031 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    | 99.187     | 99.187     | 99.187     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075525   | 0.075525   | 0.075525   |   0.0 |  0.08
Output  | 0.00015619 | 0.00015619 | 0.00015619 |   0.0 |  0.00
Modify  | 0.36711    | 0.36711    | 0.36711    |   0.0 |  0.37
Other   |            | 0.05805    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116244.0 ave      116244 max      116244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116244
Ave neighs/atom = 58.122000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.586845461429, Press = 6.7504610720926
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8030.2157   -8030.2157    -8113.815    -8113.815    323.53803    323.53803    24089.563    24089.563    876.24889    876.24889 
   25000   -8032.9313   -8032.9313   -8113.4079   -8113.4079    311.45273    311.45273    24120.227    24120.227   -1597.1843   -1597.1843 
Loop time of 101.055 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.855 ns/day, 28.071 hours/ns, 9.896 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    | 100.54     | 100.54     | 100.54     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077021   | 0.077021   | 0.077021   |   0.0 |  0.08
Output  | 0.00015551 | 0.00015551 | 0.00015551 |   0.0 |  0.00
Modify  | 0.37856    | 0.37856    | 0.37856    |   0.0 |  0.37
Other   |            | 0.05835    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2948.00 ave        2948 max        2948 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116222.0 ave      116222 max      116222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116222
Ave neighs/atom = 58.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 = 312.680100381483, Press = 6.16486983159174
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8032.9313   -8032.9313   -8113.4079   -8113.4079    311.45273    311.45273    24120.227    24120.227   -1597.1843   -1597.1843 
   26000   -8026.6255   -8026.6255   -8108.5827   -8108.5827    317.18284    317.18284    24135.843    24135.843   -2056.8707   -2056.8707 
Loop time of 99.6042 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.867 ns/day, 27.668 hours/ns, 10.040 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    | 99.101     | 99.101     | 99.101     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076185   | 0.076185   | 0.076185   |   0.0 |  0.08
Output  | 0.00015143 | 0.00015143 | 0.00015143 |   0.0 |  0.00
Modify  | 0.36928    | 0.36928    | 0.36928    |   0.0 |  0.37
Other   |            | 0.0578     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116206.0 ave      116206 max      116206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116206
Ave neighs/atom = 58.103000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.812380877563, Press = 1.50070176907781
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -8026.6255   -8026.6255   -8108.5827   -8108.5827    317.18284    317.18284    24135.843    24135.843   -2056.8707   -2056.8707 
   27000   -8034.6404   -8034.6404   -8113.7593   -8113.7593    306.19822    306.19822    24073.181    24073.181     1923.645     1923.645 
Loop time of 98.6082 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.391 hours/ns, 10.141 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    | 98.111     | 98.111     | 98.111     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075652   | 0.075652   | 0.075652   |   0.0 |  0.08
Output  | 0.0001555  | 0.0001555  | 0.0001555  |   0.0 |  0.00
Modify  | 0.36421    | 0.36421    | 0.36421    |   0.0 |  0.37
Other   |            | 0.05715    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2951.00 ave        2951 max        2951 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116236.0 ave      116236 max      116236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116236
Ave neighs/atom = 58.118000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.891763509162, Press = 1.39316348043473
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8034.6404   -8034.6404   -8113.7593   -8113.7593    306.19822    306.19822    24073.181    24073.181     1923.645     1923.645 
   28000   -8032.6456   -8032.6456   -8113.6502   -8113.6502    313.49611    313.49611    24070.122    24070.122    2205.3698    2205.3698 
Loop time of 98.8336 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.454 hours/ns, 10.118 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.336     | 98.336     | 98.336     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075218   | 0.075218   | 0.075218   |   0.0 |  0.08
Output  | 0.00015632 | 0.00015632 | 0.00015632 |   0.0 |  0.00
Modify  | 0.36434    | 0.36434    | 0.36434    |   0.0 |  0.37
Other   |            | 0.05757    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2943.00 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116224.0 ave      116224 max      116224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116224
Ave neighs/atom = 58.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 = 312.90931826387, Press = 5.9285939438389
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8032.6456   -8032.6456   -8113.6502   -8113.6502    313.49611    313.49611    24070.122    24070.122    2205.3698    2205.3698 
   29000   -8032.7679   -8032.7679   -8115.0925   -8115.0925     318.6047     318.6047    24117.324    24117.324   -1588.0325   -1588.0325 
Loop time of 101.37 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.852 ns/day, 28.158 hours/ns, 9.865 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    | 100.86     | 100.86     | 100.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076304   | 0.076304   | 0.076304   |   0.0 |  0.08
Output  | 0.00021754 | 0.00021754 | 0.00021754 |   0.0 |  0.00
Modify  | 0.37804    | 0.37804    | 0.37804    |   0.0 |  0.37
Other   |            | 0.05816    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2943.00 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116212.0 ave      116212 max      116212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116212
Ave neighs/atom = 58.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 = 312.97266469707, Press = 5.54069731258792
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8032.7679   -8032.7679   -8115.0925   -8115.0925     318.6047     318.6047    24117.324    24117.324   -1588.0325   -1588.0325 
   30000   -8029.5514   -8029.5514   -8113.5728   -8113.5728    325.17141    325.17141      24123.8      24123.8   -1794.2953   -1794.2953 
Loop time of 100.956 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.856 ns/day, 28.043 hours/ns, 9.905 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    | 100.44     | 100.44     | 100.44     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076584   | 0.076584   | 0.076584   |   0.0 |  0.08
Output  | 0.00018869 | 0.00018869 | 0.00018869 |   0.0 |  0.00
Modify  | 0.37684    | 0.37684    | 0.37684    |   0.0 |  0.37
Other   |            | 0.05803    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2944.00 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116216.0 ave      116216 max      116216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116216
Ave neighs/atom = 58.108000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.076860589116, Press = 1.99224294200149
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8029.5514   -8029.5514   -8113.5728   -8113.5728    325.17141    325.17141      24123.8      24123.8   -1794.2953   -1794.2953 
   31000   -8034.2716   -8034.2716   -8114.8348   -8114.8348    311.78775    311.78775    24081.311    24081.311    1270.4446    1270.4446 
Loop time of 101.682 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.850 ns/day, 28.245 hours/ns, 9.835 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    | 101.17     | 101.17     | 101.17     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076589   | 0.076589   | 0.076589   |   0.0 |  0.08
Output  | 0.00014735 | 0.00014735 | 0.00014735 |   0.0 |  0.00
Modify  | 0.37939    | 0.37939    | 0.37939    |   0.0 |  0.37
Other   |            | 0.05794    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2947.00 ave        2947 max        2947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116224.0 ave      116224 max      116224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116224
Ave neighs/atom = 58.112000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.197114856626, Press = 2.62385708269208
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8034.2716   -8034.2716   -8114.8348   -8114.8348    311.78775    311.78775    24081.311    24081.311    1270.4446    1270.4446 
   32000   -8029.2682   -8029.2682   -8110.1211   -8110.1211    312.90921    312.90921    24094.334    24094.334    831.45442    831.45442 
Loop time of 100.577 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.859 ns/day, 27.938 hours/ns, 9.943 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    | 100.07     | 100.07     | 100.07     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075752   | 0.075752   | 0.075752   |   0.0 |  0.08
Output  | 0.00015311 | 0.00015311 | 0.00015311 |   0.0 |  0.00
Modify  | 0.37397    | 0.37397    | 0.37397    |   0.0 |  0.37
Other   |            | 0.05797    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2946.00 ave        2946 max        2946 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116216.0 ave      116216 max      116216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116216
Ave neighs/atom = 58.108000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.239905133373, Press = 3.96762419872153
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -8029.2682   -8029.2682   -8110.1211   -8110.1211    312.90921    312.90921    24094.334    24094.334    831.45442    831.45442 
   33000   -8033.6447   -8033.6447   -8115.6419   -8115.6419    317.33779    317.33779    24107.683    24107.683   -934.58028   -934.58028 
Loop time of 99.2844 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.579 hours/ns, 10.072 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    | 98.784     | 98.784     | 98.784     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075544   | 0.075544   | 0.075544   |   0.0 |  0.08
Output  | 0.00015659 | 0.00015659 | 0.00015659 |   0.0 |  0.00
Modify  | 0.36683    | 0.36683    | 0.36683    |   0.0 |  0.37
Other   |            | 0.05773    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2942.00 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116224.0 ave      116224 max      116224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116224
Ave neighs/atom = 58.112000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.275121877477, Press = 3.2910275615481
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -8033.6447   -8033.6447   -8115.6419   -8115.6419    317.33779    317.33779    24107.683    24107.683   -934.58028   -934.58028 
   34000   -8031.2082   -8031.2082   -8113.4008   -8113.4008    318.09387    318.09387    24100.047    24100.047    -69.20899    -69.20899 
Loop time of 98.7637 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.434 hours/ns, 10.125 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.264     | 98.264     | 98.264     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075686   | 0.075686   | 0.075686   |   0.0 |  0.08
Output  | 0.00020415 | 0.00020415 | 0.00020415 |   0.0 |  0.00
Modify  | 0.36702    | 0.36702    | 0.36702    |   0.0 |  0.37
Other   |            | 0.05693    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2944.00 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116166.0 ave      116166 max      116166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116166
Ave neighs/atom = 58.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 = 313.244108811006, Press = 2.36631452657419
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -8031.2082   -8031.2082   -8113.4008   -8113.4008    318.09387    318.09387    24100.047    24100.047    -69.20899    -69.20899 
   35000   -8032.9409   -8032.9409    -8114.389    -8114.389     315.2124     315.2124    24083.414    24083.414    1140.7908    1140.7908 
Loop time of 99.0904 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.525 hours/ns, 10.092 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    | 98.591     | 98.591     | 98.591     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075022   | 0.075022   | 0.075022   |   0.0 |  0.08
Output  | 0.00022202 | 0.00022202 | 0.00022202 |   0.0 |  0.00
Modify  | 0.36652    | 0.36652    | 0.36652    |   0.0 |  0.37
Other   |            | 0.0576     |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116214.0 ave      116214 max      116214 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116214
Ave neighs/atom = 58.107000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.196577543991, Press = 2.92082220480239
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8032.9409   -8032.9409    -8114.389    -8114.389     315.2124     315.2124    24083.414    24083.414    1140.7908    1140.7908 
   36000   -8031.5547   -8031.5547    -8113.959    -8113.959    318.91335    318.91335      24099.5      24099.5    8.5756545    8.5756545 
Loop time of 101.3 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.853 ns/day, 28.139 hours/ns, 9.872 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    | 100.79     | 100.79     | 100.79     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076887   | 0.076887   | 0.076887   |   0.0 |  0.08
Output  | 0.00015343 | 0.00015343 | 0.00015343 |   0.0 |  0.00
Modify  | 0.37475    | 0.37475    | 0.37475    |   0.0 |  0.37
Other   |            | 0.058      |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2943.00 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116238.0 ave      116238 max      116238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116238
Ave neighs/atom = 58.119000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.110704005609, Press = 3.87051658413791
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -8031.5547   -8031.5547    -8113.959    -8113.959    318.91335    318.91335      24099.5      24099.5    8.5756545    8.5756545 
   37000   -8034.9354   -8034.9354   -8112.4209   -8112.4209    299.87719    299.87719    24123.378    24123.378   -1888.6704   -1888.6704 
Loop time of 99.3532 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.598 hours/ns, 10.065 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    | 98.846     | 98.846     | 98.846     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077114   | 0.077114   | 0.077114   |   0.0 |  0.08
Output  | 0.00015312 | 0.00015312 | 0.00015312 |   0.0 |  0.00
Modify  | 0.37206    | 0.37206    | 0.37206    |   0.0 |  0.37
Other   |            | 0.05797    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2943.00 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116232.0 ave      116232 max      116232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116232
Ave neighs/atom = 58.116000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.116453984229, Press = 2.42129149082357
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -8034.9354   -8034.9354   -8112.4209   -8112.4209    299.87719    299.87719    24123.378    24123.378   -1888.6704   -1888.6704 
   38000   -8033.7812   -8033.7812   -8113.0776   -8113.0776    306.88543    306.88543    24093.765    24093.765    418.27324    418.27324 
Loop time of 99.1099 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.531 hours/ns, 10.090 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    | 98.608     | 98.608     | 98.608     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075584   | 0.075584   | 0.075584   |   0.0 |  0.08
Output  | 0.00015743 | 0.00015743 | 0.00015743 |   0.0 |  0.00
Modify  | 0.36832    | 0.36832    | 0.36832    |   0.0 |  0.37
Other   |            | 0.05769    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2945.00 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116206.0 ave      116206 max      116206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116206
Ave neighs/atom = 58.103000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.095185887132, Press = -0.471080606886613
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -8033.7812   -8033.7812   -8113.0776   -8113.0776    306.88543    306.88543    24093.765    24093.765    418.27324    418.27324 
   39000   -8036.1176   -8036.1176    -8115.262    -8115.262    306.29714    306.29714    24045.347    24045.347    3721.8293    3721.8293 
Loop time of 98.4929 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.359 hours/ns, 10.153 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    | 97.994     | 97.994     | 97.994     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075193   | 0.075193   | 0.075193   |   0.0 |  0.08
Output  | 0.0002127  | 0.0002127  | 0.0002127  |   0.0 |  0.00
Modify  | 0.36638    | 0.36638    | 0.36638    |   0.0 |  0.37
Other   |            | 0.05749    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2945.00 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116236.0 ave      116236 max      116236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116236
Ave neighs/atom = 58.118000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.131464278005, Press = 2.74037079356194
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8036.1176   -8036.1176    -8115.262    -8115.262    306.29714    306.29714    24045.347    24045.347    3721.8293    3721.8293 
   40000   -8032.0519   -8032.0519   -8113.7627   -8113.7627    316.22909    316.22909    24101.025    24101.025   -103.73917   -103.73917 
Loop time of 98.7532 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.431 hours/ns, 10.126 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.255     | 98.255     | 98.255     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075078   | 0.075078   | 0.075078   |   0.0 |  0.08
Output  | 0.00015532 | 0.00015532 | 0.00015532 |   0.0 |  0.00
Modify  | 0.36633    | 0.36633    | 0.36633    |   0.0 |  0.37
Other   |            | 0.05712    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2942.00 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116248.0 ave      116248 max      116248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116248
Ave neighs/atom = 58.124000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.092713446209, Press = 3.77827618356191
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -8032.0519   -8032.0519   -8113.7627   -8113.7627    316.22909    316.22909    24101.025    24101.025   -103.73917   -103.73917 
   41000   -8035.1322   -8035.1322   -8116.1616   -8116.1616    313.59212    313.59212    24118.851    24118.851   -1814.1585   -1814.1585 
Loop time of 97.5415 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.886 ns/day, 27.095 hours/ns, 10.252 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    | 97.046     | 97.046     | 97.046     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074747   | 0.074747   | 0.074747   |   0.0 |  0.08
Output  | 0.0013295  | 0.0013295  | 0.0013295  |   0.0 |  0.00
Modify  | 0.36209    | 0.36209    | 0.36209    |   0.0 |  0.37
Other   |            | 0.05716    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2944.00 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116212.0 ave      116212 max      116212 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116212
Ave neighs/atom = 58.106000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.018711305824, Press = 2.13997660858402
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -8035.1322   -8035.1322   -8116.1616   -8116.1616    313.59212    313.59212    24118.851    24118.851   -1814.1585   -1814.1585 
   42000   -8031.5168   -8031.5168   -8111.7781   -8111.7781     310.6195     310.6195    24094.798    24094.798    580.15047    580.15047 
Loop time of 98.4057 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.335 hours/ns, 10.162 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    | 97.906     | 97.906     | 97.906     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074811   | 0.074811   | 0.074811   |   0.0 |  0.08
Output  | 0.00019798 | 0.00019798 | 0.00019798 |   0.0 |  0.00
Modify  | 0.36704    | 0.36704    | 0.36704    |   0.0 |  0.37
Other   |            | 0.05787    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2944.00 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116198.0 ave      116198 max      116198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116198
Ave neighs/atom = 58.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 = 312.963066217049, Press = 0.942979739711112
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -8031.5168   -8031.5168   -8111.7781   -8111.7781     310.6195     310.6195    24094.798    24094.798    580.15047    580.15047 
   43000   -8031.8035   -8031.8035   -8113.1532   -8113.1532    314.83199    314.83199    24070.367    24070.367    2217.7971    2217.7971 
Loop time of 98.07 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.242 hours/ns, 10.197 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    | 97.574     | 97.574     | 97.574     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075463   | 0.075463   | 0.075463   |   0.0 |  0.08
Output  | 0.00015161 | 0.00015161 | 0.00015161 |   0.0 |  0.00
Modify  | 0.36291    | 0.36291    | 0.36291    |   0.0 |  0.37
Other   |            | 0.05711    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2942.00 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116248.0 ave      116248 max      116248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116248
Ave neighs/atom = 58.124000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.950787430134, Press = 2.93292311837871
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8031.8035   -8031.8035   -8113.1532   -8113.1532    314.83199    314.83199    24070.367    24070.367    2217.7971    2217.7971 
   44000   -8033.4677   -8033.4677   -8112.9336   -8112.9336    307.54145    307.54145    24110.958    24110.958   -798.78683   -798.78683 
Loop time of 98.1127 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.881 ns/day, 27.254 hours/ns, 10.192 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.618     | 97.618     | 97.618     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074432   | 0.074432   | 0.074432   |   0.0 |  0.08
Output  | 0.00015535 | 0.00015535 | 0.00015535 |   0.0 |  0.00
Modify  | 0.36225    | 0.36225    | 0.36225    |   0.0 |  0.37
Other   |            | 0.05743    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2943.00 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116232.0 ave      116232 max      116232 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116232
Ave neighs/atom = 58.116000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.020453096729, Press = 4.11728033077482
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -8033.4677   -8033.4677   -8112.9336   -8112.9336    307.54145    307.54145    24110.958    24110.958   -798.78683   -798.78683 
   45000   -8028.3594   -8028.3594   -8114.0799   -8114.0799    331.74743    331.74743    24158.103    24158.103   -4372.0761   -4372.0761 
Loop time of 99.4314 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.869 ns/day, 27.620 hours/ns, 10.057 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    | 98.929     | 98.929     | 98.929     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075832   | 0.075832   | 0.075832   |   0.0 |  0.08
Output  | 0.00015783 | 0.00015783 | 0.00015783 |   0.0 |  0.00
Modify  | 0.36914    | 0.36914    | 0.36914    |   0.0 |  0.37
Other   |            | 0.05751    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2942.00 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116234.0 ave      116234 max      116234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116234
Ave neighs/atom = 58.117000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.070215896596, Press = 1.20870781136659
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -8028.3594   -8028.3594   -8114.0799   -8114.0799    331.74743    331.74743    24158.103    24158.103   -4372.0761   -4372.0761 
   46000   -8033.9038   -8033.9038   -8114.6591   -8114.6591    312.53162    312.53162    24088.052    24088.052    794.50757    794.50757 
Loop time of 97.0873 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.890 ns/day, 26.969 hours/ns, 10.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    | 96.596     | 96.596     | 96.596     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074653   | 0.074653   | 0.074653   |   0.0 |  0.08
Output  | 0.00015694 | 0.00015694 | 0.00015694 |   0.0 |  0.00
Modify  | 0.36013    | 0.36013    | 0.36013    |   0.0 |  0.37
Other   |            | 0.05674    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116188.0 ave      116188 max      116188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116188
Ave neighs/atom = 58.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 = 313.111469994922, Press = 0.833887222972718
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -8033.9038   -8033.9038   -8114.6591   -8114.6591    312.53162    312.53162    24088.052    24088.052    794.50757    794.50757 
   47000   -8036.9017   -8036.9017   -8118.1077   -8118.1077    314.27576    314.27576    24078.804    24078.804     1008.281     1008.281 
Loop time of 97.9814 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.217 hours/ns, 10.206 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    | 97.488     | 97.488     | 97.488     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07496    | 0.07496    | 0.07496    |   0.0 |  0.08
Output  | 0.00015387 | 0.00015387 | 0.00015387 |   0.0 |  0.00
Modify  | 0.36105    | 0.36105    | 0.36105    |   0.0 |  0.37
Other   |            | 0.05763    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2943.00 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116210.0 ave      116210 max      116210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116210
Ave neighs/atom = 58.105000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.110389186971, Press = 2.1989653189683
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -8036.9017   -8036.9017   -8118.1077   -8118.1077    314.27576    314.27576    24078.804    24078.804     1008.281     1008.281 
   48000   -8031.9761   -8031.9761   -8113.6672   -8113.6672    316.15306    316.15306    24107.582    24107.582   -541.06805   -541.06805 
Loop time of 99.216 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.560 hours/ns, 10.079 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    | 98.714     | 98.714     | 98.714     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075481   | 0.075481   | 0.075481   |   0.0 |  0.08
Output  | 0.00015445 | 0.00015445 | 0.00015445 |   0.0 |  0.00
Modify  | 0.36854    | 0.36854    | 0.36854    |   0.0 |  0.37
Other   |            | 0.05786    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2943.00 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116204.0 ave      116204 max      116204 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116204
Ave neighs/atom = 58.102000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.057400412227, Press = 2.98080482496901
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -8031.9761   -8031.9761   -8113.6672   -8113.6672    316.15306    316.15306    24107.582    24107.582   -541.06805   -541.06805 
   49000   -8037.9541   -8037.9541   -8115.9673   -8115.9673    301.91897    301.91897     24129.81     24129.81   -2836.0429   -2836.0429 
Loop time of 99.0248 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.873 ns/day, 27.507 hours/ns, 10.098 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    | 98.527     | 98.527     | 98.527     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075436   | 0.075436   | 0.075436   |   0.0 |  0.08
Output  | 0.00015538 | 0.00015538 | 0.00015538 |   0.0 |  0.00
Modify  | 0.36467    | 0.36467    | 0.36467    |   0.0 |  0.37
Other   |            | 0.05774    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116190.0 ave      116190 max      116190 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116190
Ave neighs/atom = 58.095000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.013380415273, Press = 1.48638795347706
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -8037.9541   -8037.9541   -8115.9673   -8115.9673    301.91897    301.91897     24129.81     24129.81   -2836.0429   -2836.0429 
   50000   -8033.0292   -8033.0292   -8116.6416   -8116.6416    323.58864    323.58864    24089.326    24089.326    592.16566    592.16566 
Loop time of 99.5952 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.868 ns/day, 27.665 hours/ns, 10.041 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    | 99.089     | 99.089     | 99.089     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076935   | 0.076935   | 0.076935   |   0.0 |  0.08
Output  | 0.00015495 | 0.00015495 | 0.00015495 |   0.0 |  0.00
Modify  | 0.37116    | 0.37116    | 0.37116    |   0.0 |  0.37
Other   |            | 0.05806    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2945.00 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116216.0 ave      116216 max      116216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116216
Ave neighs/atom = 58.108000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.018234578412, Press = -1.40289726998731
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -8033.0292   -8033.0292   -8116.6416   -8116.6416    323.58864    323.58864    24089.326    24089.326    592.16566    592.16566 
   51000   -8030.9652   -8030.9652    -8111.899    -8111.899    313.22195    313.22195    24068.104    24068.104    2620.7245    2620.7245 
Loop time of 99.8143 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.866 ns/day, 27.726 hours/ns, 10.019 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    | 99.309     | 99.309     | 99.309     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075908   | 0.075908   | 0.075908   |   0.0 |  0.08
Output  | 0.00015267 | 0.00015267 | 0.00015267 |   0.0 |  0.00
Modify  | 0.37208    | 0.37208    | 0.37208    |   0.0 |  0.37
Other   |            | 0.05734    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2943.00 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116168.0 ave      116168 max      116168 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116168
Ave neighs/atom = 58.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 = 313.048107363873, Press = 2.53911461191196
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -8030.9652   -8030.9652    -8111.899    -8111.899    313.22195    313.22195    24068.104    24068.104    2620.7245    2620.7245 
   52000   -8030.8807   -8030.8807   -8112.0273   -8112.0273    314.04569    314.04569    24111.511    24111.511   -670.59312   -670.59312 
Loop time of 98.2265 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.285 hours/ns, 10.181 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    | 97.728     | 97.728     | 97.728     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075387   | 0.075387   | 0.075387   |   0.0 |  0.08
Output  | 0.00015447 | 0.00015447 | 0.00015447 |   0.0 |  0.00
Modify  | 0.36569    | 0.36569    | 0.36569    |   0.0 |  0.37
Other   |            | 0.05749    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2942.00 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116258.0 ave      116258 max      116258 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116258
Ave neighs/atom = 58.129000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.124501876988, Press = 3.1188851615338
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -8030.8807   -8030.8807   -8112.0273   -8112.0273    314.04569    314.04569    24111.511    24111.511   -670.59312   -670.59312 
   53000   -8033.0096   -8033.0096   -8113.3021   -8113.3021    310.74033    310.74033    24129.574    24129.574   -2242.1866   -2242.1866 
Loop time of 99.126 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.535 hours/ns, 10.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    | 98.621     | 98.621     | 98.621     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076307   | 0.076307   | 0.076307   |   0.0 |  0.08
Output  | 0.00015539 | 0.00015539 | 0.00015539 |   0.0 |  0.00
Modify  | 0.37042    | 0.37042    | 0.37042    |   0.0 |  0.37
Other   |            | 0.05797    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2944.00 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116224.0 ave      116224 max      116224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116224
Ave neighs/atom = 58.112000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.133049559255, Press = 1.51636853541877
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -8033.0096   -8033.0096   -8113.3021   -8113.3021    310.74033    310.74033    24129.574    24129.574   -2242.1866   -2242.1866 
   54000   -8029.9791   -8029.9791   -8110.9788   -8110.9788    313.47704    313.47704    24096.906    24096.906    582.64944    582.64944 
Loop time of 98.435 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.878 ns/day, 27.343 hours/ns, 10.159 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.936     | 97.936     | 97.936     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075018   | 0.075018   | 0.075018   |   0.0 |  0.08
Output  | 0.00015492 | 0.00015492 | 0.00015492 |   0.0 |  0.00
Modify  | 0.36613    | 0.36613    | 0.36613    |   0.0 |  0.37
Other   |            | 0.05744    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2942.00 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116196.0 ave      116196 max      116196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116196
Ave neighs/atom = 58.098000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.196645925953, Press = 0.977745244873179
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -8029.9791   -8029.9791   -8110.9788   -8110.9788    313.47704    313.47704    24096.906    24096.906    582.64944    582.64944 
   55000   -8030.5707   -8030.5707   -8112.7567   -8112.7567    318.06799    318.06799    24070.916    24070.916    2319.4009    2319.4009 
Loop time of 97.821 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.172 hours/ns, 10.223 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.33      | 97.33      | 97.33      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074275   | 0.074275   | 0.074275   |   0.0 |  0.08
Output  | 0.00015568 | 0.00015568 | 0.00015568 |   0.0 |  0.00
Modify  | 0.36007    | 0.36007    | 0.36007    |   0.0 |  0.37
Other   |            | 0.05689    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2945.00 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116256.0 ave      116256 max      116256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116256
Ave neighs/atom = 58.128000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.196780434859, Press = 2.25225620665647
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -8030.5707   -8030.5707   -8112.7567   -8112.7567    318.06799    318.06799    24070.916    24070.916    2319.4009    2319.4009 
   56000   -8036.2908   -8036.2908     -8115.24     -8115.24    305.54151    305.54151    24103.866    24103.866   -533.71015   -533.71015 
Loop time of 98.1574 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.266 hours/ns, 10.188 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.66      | 97.66      | 97.66      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07545    | 0.07545    | 0.07545    |   0.0 |  0.08
Output  | 0.00015735 | 0.00015735 | 0.00015735 |   0.0 |  0.00
Modify  | 0.36413    | 0.36413    | 0.36413    |   0.0 |  0.37
Other   |            | 0.05734    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2947.00 ave        2947 max        2947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116242.0 ave      116242 max      116242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116242
Ave neighs/atom = 58.121000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.164544202403, Press = 4.17717661753793
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -8036.2908   -8036.2908     -8115.24     -8115.24    305.54151    305.54151    24103.866    24103.866   -533.71015   -533.71015 
   57000   -8032.1098   -8032.1098   -8112.3786   -8112.3786    310.64876    310.64876    24141.839    24141.839   -3097.3955   -3097.3955 
Loop time of 99.4145 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.869 ns/day, 27.615 hours/ns, 10.059 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.913     | 98.913     | 98.913     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075108   | 0.075108   | 0.075108   |   0.0 |  0.08
Output  | 0.00015472 | 0.00015472 | 0.00015472 |   0.0 |  0.00
Modify  | 0.3687     | 0.3687     | 0.3687     |   0.0 |  0.37
Other   |            | 0.05761    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2944.00 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116206.0 ave      116206 max      116206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116206
Ave neighs/atom = 58.103000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.127428071836, Press = 1.53949187889922
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -8032.1098   -8032.1098   -8112.3786   -8112.3786    310.64876    310.64876    24141.839    24141.839   -3097.3955   -3097.3955 
   58000   -8032.3151   -8032.3151   -8113.5551   -8113.5551    314.40738    314.40738    24090.558    24090.558    853.06976    853.06976 
Loop time of 98.535 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.877 ns/day, 27.371 hours/ns, 10.149 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    | 98.04      | 98.04      | 98.04      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074662   | 0.074662   | 0.074662   |   0.0 |  0.08
Output  | 0.00015519 | 0.00015519 | 0.00015519 |   0.0 |  0.00
Modify  | 0.36373    | 0.36373    | 0.36373    |   0.0 |  0.37
Other   |            | 0.05675    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116170.0 ave      116170 max      116170 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116170
Ave neighs/atom = 58.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 = 313.110960085973, Press = 1.07877646962781
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -8032.3151   -8032.3151   -8113.5551   -8113.5551    314.40738    314.40738    24090.558    24090.558    853.06976    853.06976 
   59000   -8033.2807   -8033.2807   -8115.7205   -8115.7205    319.05056    319.05056    24081.726    24081.726    1131.6592    1131.6592 
Loop time of 99.4216 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.869 ns/day, 27.617 hours/ns, 10.058 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    | 98.919     | 98.919     | 98.919     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075324   | 0.075324   | 0.075324   |   0.0 |  0.08
Output  | 0.00018835 | 0.00018835 | 0.00018835 |   0.0 |  0.00
Modify  | 0.36892    | 0.36892    | 0.36892    |   0.0 |  0.37
Other   |            | 0.05797    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2943.00 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116208.0 ave      116208 max      116208 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116208
Ave neighs/atom = 58.104000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.155392542366, Press = 2.16472441254093
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -8033.2807   -8033.2807   -8115.7205   -8115.7205    319.05056    319.05056    24081.726    24081.726    1131.6592    1131.6592 
   60000   -8030.1516   -8030.1516   -8113.2668   -8113.2668    321.66473    321.66473    24110.291    24110.291   -714.88413   -714.88413 
Loop time of 98.1504 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.264 hours/ns, 10.188 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.655     | 97.655     | 97.655     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0748     | 0.0748     | 0.0748     |   0.0 |  0.08
Output  | 0.0001586  | 0.0001586  | 0.0001586  |   0.0 |  0.00
Modify  | 0.36354    | 0.36354    | 0.36354    |   0.0 |  0.37
Other   |            | 0.05725    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116228.0 ave      116228 max      116228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116228
Ave neighs/atom = 58.114000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.165320198152, Press = 2.32171797287163
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -8030.1516   -8030.1516   -8113.2668   -8113.2668    321.66473    321.66473    24110.291    24110.291   -714.88413   -714.88413 
   61000   -8032.4634   -8032.4634   -8113.0152   -8113.0152    311.74377    311.74377    24115.578    24115.578   -1245.6275   -1245.6275 
Loop time of 98.87 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.464 hours/ns, 10.114 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    | 98.372     | 98.372     | 98.372     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076186   | 0.076186   | 0.076186   |   0.0 |  0.08
Output  | 0.00015547 | 0.00015547 | 0.00015547 |   0.0 |  0.00
Modify  | 0.36502    | 0.36502    | 0.36502    |   0.0 |  0.37
Other   |            | 0.05695    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2948.00 ave        2948 max        2948 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116182.0 ave      116182 max      116182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116182
Ave neighs/atom = 58.091000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.229938553482, Press = 0.941161162412551
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -8032.4634   -8032.4634   -8113.0152   -8113.0152    311.74377    311.74377    24115.578    24115.578   -1245.6275   -1245.6275 
   62000    -8032.255    -8032.255   -8114.5531   -8114.5531    318.50206    318.50206    24074.338    24074.338    1825.2304    1825.2304 
Loop time of 98.765 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.435 hours/ns, 10.125 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    | 98.266     | 98.266     | 98.266     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075303   | 0.075303   | 0.075303   |   0.0 |  0.08
Output  | 0.00015769 | 0.00015769 | 0.00015769 |   0.0 |  0.00
Modify  | 0.36556    | 0.36556    | 0.36556    |   0.0 |  0.37
Other   |            | 0.05779    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116256.0 ave      116256 max      116256 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116256
Ave neighs/atom = 58.128000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.251327189271, Press = 0.775386779310792
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000    -8032.255    -8032.255   -8114.5531   -8114.5531    318.50206    318.50206    24074.338    24074.338    1825.2304    1825.2304 
   63000   -8035.9592   -8035.9592     -8115.67     -8115.67     308.4891     308.4891    24057.094    24057.094    2922.6585    2922.6585 
Loop time of 98.1822 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.880 ns/day, 27.273 hours/ns, 10.185 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    | 97.685     | 97.685     | 97.685     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075832   | 0.075832   | 0.075832   |   0.0 |  0.08
Output  | 0.00015751 | 0.00015751 | 0.00015751 |   0.0 |  0.00
Modify  | 0.36373    | 0.36373    | 0.36373    |   0.0 |  0.37
Other   |            | 0.05709    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2946.00 ave        2946 max        2946 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116224.0 ave      116224 max      116224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116224
Ave neighs/atom = 58.112000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.267537160309, Press = 2.84736046621806
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -8035.9592   -8035.9592     -8115.67     -8115.67     308.4891     308.4891    24057.094    24057.094    2922.6585    2922.6585 
   64000   -8032.3725   -8032.3725   -8111.1727   -8111.1727    304.96504    304.96504    24129.159    24129.159   -2122.5079   -2122.5079 
Loop time of 97.9405 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.882 ns/day, 27.206 hours/ns, 10.210 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    | 97.444     | 97.444     | 97.444     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075312   | 0.075312   | 0.075312   |   0.0 |  0.08
Output  | 0.00015411 | 0.00015411 | 0.00015411 |   0.0 |  0.00
Modify  | 0.36416    | 0.36416    | 0.36416    |   0.0 |  0.37
Other   |            | 0.05737    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2944.00 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116240.0 ave      116240 max      116240 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116240
Ave neighs/atom = 58.120000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.265215606905, Press = 2.53455369535771
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -8032.3725   -8032.3725   -8111.1727   -8111.1727    304.96504    304.96504    24129.159    24129.159   -2122.5079   -2122.5079 
   65000   -8034.4876   -8034.4876   -8116.2476   -8116.2476    316.41965    316.41965    24121.541    24121.541   -1984.1639   -1984.1639 
Loop time of 98.6695 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.876 ns/day, 27.408 hours/ns, 10.135 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    | 98.172     | 98.172     | 98.172     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075023   | 0.075023   | 0.075023   |   0.0 |  0.08
Output  | 0.00015277 | 0.00015277 | 0.00015277 |   0.0 |  0.00
Modify  | 0.36475    | 0.36475    | 0.36475    |   0.0 |  0.37
Other   |            | 0.05712    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116210.0 ave      116210 max      116210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116210
Ave neighs/atom = 58.105000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.257477848523, Press = 0.680654642144151
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -8034.4876   -8034.4876   -8116.2476   -8116.2476    316.41965    316.41965    24121.541    24121.541   -1984.1639   -1984.1639 
   66000   -8029.2041   -8029.2041   -8110.7063   -8110.7063    315.42172    315.42172    24075.518    24075.518    2176.1547    2176.1547 
Loop time of 99.2154 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.871 ns/day, 27.560 hours/ns, 10.079 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    | 98.715     | 98.715     | 98.715     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075336   | 0.075336   | 0.075336   |   0.0 |  0.08
Output  | 0.00015654 | 0.00015654 | 0.00015654 |   0.0 |  0.00
Modify  | 0.36704    | 0.36704    | 0.36704    |   0.0 |  0.37
Other   |            | 0.05768    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116176.0 ave      116176 max      116176 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116176
Ave neighs/atom = 58.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 = 313.262132673872, Press = 1.12541398210002
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000   -8029.2041   -8029.2041   -8110.7063   -8110.7063    315.42172    315.42172    24075.518    24075.518    2176.1547    2176.1547 
   67000   -8032.0906   -8032.0906   -8112.0714   -8112.0714    309.53377    309.53377    24084.482    24084.482    1340.2872    1340.2872 
Loop time of 97.8897 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.192 hours/ns, 10.216 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    | 97.394     | 97.394     | 97.394     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07516    | 0.07516    | 0.07516    |   0.0 |  0.08
Output  | 0.00035796 | 0.00035796 | 0.00035796 |   0.0 |  0.00
Modify  | 0.36236    | 0.36236    | 0.36236    |   0.0 |  0.37
Other   |            | 0.05774    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2944.00 ave        2944 max        2944 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116268.0 ave      116268 max      116268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116268
Ave neighs/atom = 58.134000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.265218619511, Press = 2.20532696803916
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -8032.0906   -8032.0906   -8112.0714   -8112.0714    309.53377    309.53377    24084.482    24084.482    1340.2872    1340.2872 
   68000     -8034.24     -8034.24   -8113.9363   -8113.9363    308.43297    308.43297    24101.078    24101.078   -86.057501   -86.057501 
Loop time of 100.02 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.864 ns/day, 27.783 hours/ns, 9.998 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    | 99.514     | 99.514     | 99.514     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075995   | 0.075995   | 0.075995   |   0.0 |  0.08
Output  | 0.00015624 | 0.00015624 | 0.00015624 |   0.0 |  0.00
Modify  | 0.37215    | 0.37215    | 0.37215    |   0.0 |  0.37
Other   |            | 0.05765    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2942.00 ave        2942 max        2942 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116236.0 ave      116236 max      116236 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116236
Ave neighs/atom = 58.118000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.255922105181, Press = 1.7469365454451
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000     -8034.24     -8034.24   -8113.9363   -8113.9363    308.43297    308.43297    24101.078    24101.078   -86.057501   -86.057501 
   69000   -8034.7589   -8034.7589   -8115.9308   -8115.9308    314.14375    314.14375    24103.856    24103.856   -651.82738   -651.82738 
Loop time of 100.43 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.860 ns/day, 27.897 hours/ns, 9.957 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    | 99.921     | 99.921     | 99.921     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076864   | 0.076864   | 0.076864   |   0.0 |  0.08
Output  | 0.00015254 | 0.00015254 | 0.00015254 |   0.0 |  0.00
Modify  | 0.37433    | 0.37433    | 0.37433    |   0.0 |  0.37
Other   |            | 0.05799    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2941.00 ave        2941 max        2941 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116238.0 ave      116238 max      116238 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116238
Ave neighs/atom = 58.119000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.202571501217, Press = 1.31288213011324
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -8034.7589   -8034.7589   -8115.9308   -8115.9308    314.14375    314.14375    24103.856    24103.856   -651.82738   -651.82738 
   70000   -8031.6191   -8031.6191    -8111.914    -8111.914    310.74952    310.74952    24096.663    24096.663    342.31917    342.31917 
Loop time of 99.3278 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.591 hours/ns, 10.068 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.825     | 98.825     | 98.825     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075549   | 0.075549   | 0.075549   |   0.0 |  0.08
Output  | 0.00024708 | 0.00024708 | 0.00024708 |   0.0 |  0.00
Modify  | 0.36913    | 0.36913    | 0.36913    |   0.0 |  0.37
Other   |            | 0.05834    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2945.00 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116216.0 ave      116216 max      116216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116216
Ave neighs/atom = 58.108000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.184558453094, Press = 1.26648458388004
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -8031.6191   -8031.6191    -8111.914    -8111.914    310.74952    310.74952    24096.663    24096.663    342.31917    342.31917 
   71000   -8033.3935   -8033.3935   -8114.2491   -8114.2491     312.9197     312.9197    24091.377    24091.377     568.3961     568.3961 
Loop time of 100.322 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.861 ns/day, 27.867 hours/ns, 9.968 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    | 99.814     | 99.814     | 99.814     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076221   | 0.076221   | 0.076221   |   0.0 |  0.08
Output  | 0.00021572 | 0.00021572 | 0.00021572 |   0.0 |  0.00
Modify  | 0.37395    | 0.37395    | 0.37395    |   0.0 |  0.37
Other   |            | 0.05767    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2943.00 ave        2943 max        2943 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116264.0 ave      116264 max      116264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116264
Ave neighs/atom = 58.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 = 313.191029178798, Press = 1.62457759682303
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -8033.3935   -8033.3935   -8114.2491   -8114.2491     312.9197     312.9197    24091.377    24091.377     568.3961     568.3961 
   72000   -8029.2999   -8029.2999    -8112.931    -8112.931    323.66082    323.66082     24109.34     24109.34   -676.96423   -676.96423 
Loop time of 96.8377 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.892 ns/day, 26.899 hours/ns, 10.327 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.348     | 96.348     | 96.348     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074853   | 0.074853   | 0.074853   |   0.0 |  0.08
Output  | 0.00015936 | 0.00015936 | 0.00015936 |   0.0 |  0.00
Modify  | 0.35755    | 0.35755    | 0.35755    |   0.0 |  0.37
Other   |            | 0.05676    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2947.00 ave        2947 max        2947 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116196.0 ave      116196 max      116196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116196
Ave neighs/atom = 58.098000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.230601523359, Press = 1.38759063494938
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -8029.2999   -8029.2999    -8112.931    -8112.931    323.66082    323.66082     24109.34     24109.34   -676.96423   -676.96423 
   73000   -8035.1408   -8035.1408   -8113.0307   -8113.0307    301.44196    301.44196    24096.311    24096.311    256.64238    256.64238 
Loop time of 98.8831 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.874 ns/day, 27.468 hours/ns, 10.113 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    | 98.384     | 98.384     | 98.384     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075296   | 0.075296   | 0.075296   |   0.0 |  0.08
Output  | 0.00015283 | 0.00015283 | 0.00015283 |   0.0 |  0.00
Modify  | 0.36677    | 0.36677    | 0.36677    |   0.0 |  0.37
Other   |            | 0.05736    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2949.00 ave        2949 max        2949 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116228.0 ave      116228 max      116228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116228
Ave neighs/atom = 58.114000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.23859093913, Press = 1.03546111578341
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -8035.1408   -8035.1408   -8113.0307   -8113.0307    301.44196    301.44196    24096.311    24096.311    256.64238    256.64238 
   74000   -8033.7501   -8033.7501    -8114.103    -8114.103    310.97409    310.97409    24080.491    24080.491    1429.9076    1429.9076 
Loop time of 97.704 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.884 ns/day, 27.140 hours/ns, 10.235 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.21      | 97.21      | 97.21      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075778   | 0.075778   | 0.075778   |   0.0 |  0.08
Output  | 0.00015747 | 0.00015747 | 0.00015747 |   0.0 |  0.00
Modify  | 0.36101    | 0.36101    | 0.36101    |   0.0 |  0.37
Other   |            | 0.05735    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2946.00 ave        2946 max        2946 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116244.0 ave      116244 max      116244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116244
Ave neighs/atom = 58.122000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.263918428014, Press = 1.24560903822647
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -8033.7501   -8033.7501    -8114.103    -8114.103    310.97409    310.97409    24080.491    24080.491    1429.9076    1429.9076 
   75000   -8035.0595   -8035.0595   -8114.8083   -8114.8083    308.63598    308.63598     24090.55     24090.55    453.47986    453.47986 
Loop time of 99.7118 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.866 ns/day, 27.698 hours/ns, 10.029 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.203     | 99.203     | 99.203     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076213   | 0.076213   | 0.076213   |   0.0 |  0.08
Output  | 0.00019042 | 0.00019042 | 0.00019042 |   0.0 |  0.00
Modify  | 0.37422    | 0.37422    | 0.37422    |   0.0 |  0.38
Other   |            | 0.05831    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2945.00 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116184.0 ave      116184 max      116184 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116184
Ave neighs/atom = 58.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 = 313.286851412287, Press = 2.07290555266994
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -8035.0595   -8035.0595   -8114.8083   -8114.8083    308.63598    308.63598     24090.55     24090.55    453.47986    453.47986 
   76000   -8028.8282   -8028.8282    -8111.644    -8111.644    320.50551    320.50551     24140.33     24140.33   -2798.4549   -2798.4549 
Loop time of 98.3327 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.315 hours/ns, 10.170 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.832     | 97.832     | 97.832     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075949   | 0.075949   | 0.075949   |   0.0 |  0.08
Output  | 0.00015759 | 0.00015759 | 0.00015759 |   0.0 |  0.00
Modify  | 0.36689    | 0.36689    | 0.36689    |   0.0 |  0.37
Other   |            | 0.05779    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2945.00 ave        2945 max        2945 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116222.0 ave      116222 max      116222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116222
Ave neighs/atom = 58.111000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.297029561519, Press = 1.40713138688105
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -8028.8282   -8028.8282    -8111.644    -8111.644    320.50551    320.50551     24140.33     24140.33   -2798.4549   -2798.4549 
   77000   -8033.5143   -8033.5143   -8113.7838   -8113.7838    310.65136    310.65136    24117.673    24117.673   -1504.7997   -1504.7997 
Loop time of 98.9387 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.873 ns/day, 27.483 hours/ns, 10.107 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    | 98.433     | 98.433     | 98.433     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07551    | 0.07551    | 0.07551    |   0.0 |  0.08
Output  | 0.00015779 | 0.00015779 | 0.00015779 |   0.0 |  0.00
Modify  | 0.37222    | 0.37222    | 0.37222    |   0.0 |  0.38
Other   |            | 0.05802    |            |       |  0.06

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        2946.00 ave        2946 max        2946 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      116206.0 ave      116206 max      116206 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116206
Ave neighs/atom = 58.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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
24099.0440845146

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0