# 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 4.044650763273239*${_u_distance}
variable latticeconst_converted equal 4.044650763273239*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04465076327324
Lattice spacing in x,y,z = 4.0446508 4.0446508 4.0446508
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 (40.446508 40.446508 40.446508)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (40.446508 40.446508 40.446508)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Al

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

kim interactions Al
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_LeeShimBaskes_2003_Al__MO_353977746962_000
pair_coeff * * Al
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 26.981538

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66167.2499448559 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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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_353977746962_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 = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -13267.791   -13267.791       -13440       -13440       333.15       333.15     66167.25     66167.25    2779.9252    2779.9252 
    1000   -13075.332   -13075.332   -13255.138   -13255.138     347.8471     347.8471    67710.433    67710.433   -1538.9085   -1538.9085 
Loop time of 137.451 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.629 ns/day, 38.181 hours/ns, 7.275 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.03     | 137.03     | 137.03     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053416   | 0.053416   | 0.053416   |   0.0 |  0.04
Output  | 0.00028871 | 0.00028871 | 0.00028871 |   0.0 |  0.00
Modify  | 0.31809    | 0.31809    | 0.31809    |   0.0 |  0.23
Other   |            | 0.05118    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312000.0 ave      312000 max      312000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312000
Ave neighs/atom = 78.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -13075.332   -13075.332   -13255.138   -13255.138     347.8471     347.8471    67710.433    67710.433   -1538.9085   -1538.9085 
    2000    -13094.78    -13094.78   -13266.554   -13266.554    332.30904    332.30904     67471.76     67471.76    218.31243    218.31243 
Loop time of 137.586 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.628 ns/day, 38.218 hours/ns, 7.268 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.16     | 137.16     | 137.16     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052812   | 0.052812   | 0.052812   |   0.0 |  0.04
Output  | 0.00014326 | 0.00014326 | 0.00014326 |   0.0 |  0.00
Modify  | 0.32286    | 0.32286    | 0.32286    |   0.0 |  0.23
Other   |            | 0.05089    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      277944.0 ave      277944 max      277944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 277944
Ave neighs/atom = 69.486000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000    -13094.78    -13094.78   -13266.554   -13266.554    332.30904    332.30904     67471.76     67471.76    218.31243    218.31243 
    3000   -13081.147   -13081.147   -13252.397   -13252.397    331.29504    331.29504    67556.434    67556.434    222.99502    222.99502 
Loop time of 137.261 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.629 ns/day, 38.128 hours/ns, 7.285 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.83     | 136.83     | 136.83     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05351    | 0.05351    | 0.05351    |   0.0 |  0.04
Output  | 0.00023629 | 0.00023629 | 0.00023629 |   0.0 |  0.00
Modify  | 0.32226    | 0.32226    | 0.32226    |   0.0 |  0.23
Other   |            | 0.0525     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280600.0 ave      280600 max      280600 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280600
Ave neighs/atom = 70.150000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13081.147   -13081.147   -13252.397   -13252.397    331.29504    331.29504    67556.434    67556.434    222.99502    222.99502 
    4000   -13091.546   -13091.546   -13261.599   -13261.599    328.97885    328.97885    67536.983    67536.983   -234.21554   -234.21554 
Loop time of 135.472 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.638 ns/day, 37.631 hours/ns, 7.382 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.05     | 135.05     | 135.05     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052317   | 0.052317   | 0.052317   |   0.0 |  0.04
Output  | 0.0001469  | 0.0001469  | 0.0001469  |   0.0 |  0.00
Modify  | 0.31693    | 0.31693    | 0.31693    |   0.0 |  0.23
Other   |            | 0.0519     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279128.0 ave      279128 max      279128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279128
Ave neighs/atom = 69.782000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -13091.546   -13091.546   -13261.599   -13261.599    328.97885    328.97885    67536.983    67536.983   -234.21554   -234.21554 
    5000   -13085.409   -13085.409   -13259.522   -13259.522    336.83332    336.83332    67526.848    67526.848    43.342808    43.342808 
Loop time of 138.108 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.626 ns/day, 38.363 hours/ns, 7.241 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.68     | 137.68     | 137.68     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053167   | 0.053167   | 0.053167   |   0.0 |  0.04
Output  | 0.00010178 | 0.00010178 | 0.00010178 |   0.0 |  0.00
Modify  | 0.32502    | 0.32502    | 0.32502    |   0.0 |  0.24
Other   |            | 0.05015    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279716.0 ave      279716 max      279716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279716
Ave neighs/atom = 69.929000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 338.07676435299, Press = -155.577778647752
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -13085.409   -13085.409   -13259.522   -13259.522    336.83332    336.83332    67526.848    67526.848    43.342808    43.342808 
    6000   -13087.077   -13087.077   -13259.932   -13259.932    334.40005    334.40005    67566.148    67566.148   -412.00228   -412.00228 
Loop time of 137.496 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.628 ns/day, 38.193 hours/ns, 7.273 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.07     | 137.07     | 137.07     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05143    | 0.05143    | 0.05143    |   0.0 |  0.04
Output  | 8.9927e-05 | 8.9927e-05 | 8.9927e-05 |   0.0 |  0.00
Modify  | 0.32785    | 0.32785    | 0.32785    |   0.0 |  0.24
Other   |            | 0.04902    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279662.0 ave      279662 max      279662 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279662
Ave neighs/atom = 69.915500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.721096282503, Press = 14.8609624886296
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13087.077   -13087.077   -13259.932   -13259.932    334.40005    334.40005    67566.148    67566.148   -412.00228   -412.00228 
    7000   -13088.301   -13088.301   -13260.149   -13260.149     332.4528     332.4528    67451.204    67451.204    832.23765    832.23765 
Loop time of 138.23 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.625 ns/day, 38.397 hours/ns, 7.234 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.8      | 137.8      | 137.8      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051761   | 0.051761   | 0.051761   |   0.0 |  0.04
Output  | 0.00023994 | 0.00023994 | 0.00023994 |   0.0 |  0.00
Modify  | 0.32862    | 0.32862    | 0.32862    |   0.0 |  0.24
Other   |            | 0.05113    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279358.0 ave      279358 max      279358 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279358
Ave neighs/atom = 69.839500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.207204837428, Press = -20.0077100176895
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13088.301   -13088.301   -13260.149   -13260.149     332.4528     332.4528    67451.204    67451.204    832.23765    832.23765 
    8000   -13087.107   -13087.107   -13255.957   -13255.957    326.65257    326.65257     67669.13     67669.13   -1389.0262   -1389.0262 
Loop time of 143.782 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.601 ns/day, 39.939 hours/ns, 6.955 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 143.33     | 143.33     | 143.33     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054216   | 0.054216   | 0.054216   |   0.0 |  0.04
Output  | 0.00010361 | 0.00010361 | 0.00010361 |   0.0 |  0.00
Modify  | 0.34385    | 0.34385    | 0.34385    |   0.0 |  0.24
Other   |            | 0.05469    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280514.0 ave      280514 max      280514 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280514
Ave neighs/atom = 70.128500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.932388236106, Press = 6.96142482293657
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -13087.107   -13087.107   -13255.957   -13255.957    326.65257    326.65257     67669.13     67669.13   -1389.0262   -1389.0262 
    9000   -13091.531   -13091.531   -13261.173   -13261.173    328.18288    328.18288    67428.825    67428.825    954.72897    954.72897 
Loop time of 142.857 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.605 ns/day, 39.682 hours/ns, 7.000 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.41     | 142.41     | 142.41     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05375    | 0.05375    | 0.05375    |   0.0 |  0.04
Output  | 0.00010949 | 0.00010949 | 0.00010949 |   0.0 |  0.00
Modify  | 0.34131    | 0.34131    | 0.34131    |   0.0 |  0.24
Other   |            | 0.05167    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      278096.0 ave      278096 max      278096 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278096
Ave neighs/atom = 69.524000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.691169895623, Press = -1.64761830756691
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13091.531   -13091.531   -13261.173   -13261.173    328.18288    328.18288    67428.825    67428.825    954.72897    954.72897 
   10000   -13086.737   -13086.737   -13259.465   -13259.465    334.15519    334.15519    67589.821    67589.821   -722.64753   -722.64753 
Loop time of 143.247 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.603 ns/day, 39.791 hours/ns, 6.981 timesteps/s
99.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    | 142.79     | 142.79     | 142.79     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054658   | 0.054658   | 0.054658   |   0.0 |  0.04
Output  | 0.00010342 | 0.00010342 | 0.00010342 |   0.0 |  0.00
Modify  | 0.34387    | 0.34387    | 0.34387    |   0.0 |  0.24
Other   |            | 0.05686    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280390.0 ave      280390 max      280390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280390
Ave neighs/atom = 70.097500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.429301239889, Press = -1.63277832710793
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13086.737   -13086.737   -13259.465   -13259.465    334.15519    334.15519    67589.821    67589.821   -722.64753   -722.64753 
   11000   -13091.706   -13091.706   -13261.436   -13261.436    328.35509    328.35509    67470.023    67470.023     566.8095     566.8095 
Loop time of 139.152 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.621 ns/day, 38.653 hours/ns, 7.186 timesteps/s
99.2% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.71     | 138.71     | 138.71     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055455   | 0.055455   | 0.055455   |   0.0 |  0.04
Output  | 0.00018879 | 0.00018879 | 0.00018879 |   0.0 |  0.00
Modify  | 0.33322    | 0.33322    | 0.33322    |   0.0 |  0.24
Other   |            | 0.05594    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279172.0 ave      279172 max      279172 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279172
Ave neighs/atom = 69.793000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.409156674063, Press = 1.39601673588233
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -13091.706   -13091.706   -13261.436   -13261.436    328.35509    328.35509    67470.023    67470.023     566.8095     566.8095 
   12000   -13087.222   -13087.222   -13259.121   -13259.121    332.55075    332.55075    67574.858    67574.858   -420.90003   -420.90003 
Loop time of 137.518 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.628 ns/day, 38.200 hours/ns, 7.272 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.08     | 137.08     | 137.08     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054569   | 0.054569   | 0.054569   |   0.0 |  0.04
Output  | 9.9873e-05 | 9.9873e-05 | 9.9873e-05 |   0.0 |  0.00
Modify  | 0.3282     | 0.3282     | 0.3282     |   0.0 |  0.24
Other   |            | 0.05495    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280244.0 ave      280244 max      280244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280244
Ave neighs/atom = 70.061000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.171938271613, Press = -3.21810224511898
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13087.222   -13087.222   -13259.121   -13259.121    332.55075    332.55075    67574.858    67574.858   -420.90003   -420.90003 
   13000   -13089.219   -13089.219    -13262.85    -13262.85    335.90109    335.90109    67490.852    67490.852    256.55814    256.55814 
Loop time of 138.217 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.625 ns/day, 38.394 hours/ns, 7.235 timesteps/s
99.4% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.78     | 137.78     | 137.78     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054625   | 0.054625   | 0.054625   |   0.0 |  0.04
Output  | 0.00012943 | 0.00012943 | 0.00012943 |   0.0 |  0.00
Modify  | 0.33101    | 0.33101    | 0.33101    |   0.0 |  0.24
Other   |            | 0.05559    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279318.0 ave      279318 max      279318 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279318
Ave neighs/atom = 69.829500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.233507125082, Press = 4.84645415419879
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13089.219   -13089.219    -13262.85    -13262.85    335.90109    335.90109    67490.852    67490.852    256.55814    256.55814 
   14000   -13086.705   -13086.705    -13259.71    -13259.71    334.68928    334.68928    67534.622    67534.622   -34.332901   -34.332901 
Loop time of 137.797 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.627 ns/day, 38.277 hours/ns, 7.257 timesteps/s
99.4% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.36     | 137.36     | 137.36     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054412   | 0.054412   | 0.054412   |   0.0 |  0.04
Output  | 0.00024918 | 0.00024918 | 0.00024918 |   0.0 |  0.00
Modify  | 0.32922    | 0.32922    | 0.32922    |   0.0 |  0.24
Other   |            | 0.05464    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279930.0 ave      279930 max      279930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279930
Ave neighs/atom = 69.982500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.168124964728, Press = -6.88487530078437
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13086.705   -13086.705    -13259.71    -13259.71    334.68928    334.68928    67534.622    67534.622   -34.332901   -34.332901 
   15000   -13091.215   -13091.215   -13258.404   -13258.404    323.43754    323.43754    67578.061    67578.061   -589.19041   -589.19041 
Loop time of 141.953 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.609 ns/day, 39.431 hours/ns, 7.045 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 141.5      | 141.5      | 141.5      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054819   | 0.054819   | 0.054819   |   0.0 |  0.04
Output  | 0.00037446 | 0.00037446 | 0.00037446 |   0.0 |  0.00
Modify  | 0.34514    | 0.34514    | 0.34514    |   0.0 |  0.24
Other   |            | 0.05731    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279866.0 ave      279866 max      279866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279866
Ave neighs/atom = 69.966500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.262954429644, Press = 2.90649522279679
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13091.215   -13091.215   -13258.404   -13258.404    323.43754    323.43754    67578.061    67578.061   -589.19041   -589.19041 
   16000   -13084.306   -13084.306   -13260.263   -13260.263    340.39955    340.39955    67482.414    67482.414    556.96573    556.96573 
Loop time of 136.973 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.631 ns/day, 38.048 hours/ns, 7.301 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.54     | 136.54     | 136.54     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055075   | 0.055075   | 0.055075   |   0.0 |  0.04
Output  | 0.00012299 | 0.00012299 | 0.00012299 |   0.0 |  0.00
Modify  | 0.32655    | 0.32655    | 0.32655    |   0.0 |  0.24
Other   |            | 0.05257    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279174.0 ave      279174 max      279174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279174
Ave neighs/atom = 69.793500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.251326815479, Press = -0.841499155481908
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13084.306   -13084.306   -13260.263   -13260.263    340.39955    340.39955    67482.414    67482.414    556.96573    556.96573 
   17000   -13091.916   -13091.916   -13262.384   -13262.384    329.78307    329.78307    67587.766    67587.766   -848.97093   -848.97093 
Loop time of 138.52 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.624 ns/day, 38.478 hours/ns, 7.219 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.08     | 138.08     | 138.08     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055116   | 0.055116   | 0.055116   |   0.0 |  0.04
Output  | 0.00017248 | 0.00017248 | 0.00017248 |   0.0 |  0.00
Modify  | 0.33073    | 0.33073    | 0.33073    |   0.0 |  0.24
Other   |            | 0.05227    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5840.00 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280252.0 ave      280252 max      280252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280252
Ave neighs/atom = 70.063000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.156581543999, Press = 0.150381660819909
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -13091.916   -13091.916   -13262.384   -13262.384    329.78307    329.78307    67587.766    67587.766   -848.97093   -848.97093 
   18000   -13086.448   -13086.448   -13260.154   -13260.154     336.0457     336.0457    67465.024    67465.024     709.1495     709.1495 
Loop time of 140.208 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.616 ns/day, 38.947 hours/ns, 7.132 timesteps/s
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.75     | 139.75     | 139.75     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.060319   | 0.060319   | 0.060319   |   0.0 |  0.04
Output  | 0.00011275 | 0.00011275 | 0.00011275 |   0.0 |  0.00
Modify  | 0.3398     | 0.3398     | 0.3398     |   0.0 |  0.24
Other   |            | 0.05366    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279308.0 ave      279308 max      279308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279308
Ave neighs/atom = 69.827000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.183882677542, Press = 0.704695248476004
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13086.448   -13086.448   -13260.154   -13260.154     336.0457     336.0457    67465.024    67465.024     709.1495     709.1495 
   19000   -13093.368   -13093.368   -13263.814   -13263.814    329.74046    329.74046    67579.805    67579.805   -905.00901   -905.00901 
Loop time of 139.616 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.17     | 139.17     | 139.17     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.057646   | 0.057646   | 0.057646   |   0.0 |  0.04
Output  | 0.00011587 | 0.00011587 | 0.00011587 |   0.0 |  0.00
Modify  | 0.33707    | 0.33707    | 0.33707    |   0.0 |  0.24
Other   |            | 0.05452    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280434.0 ave      280434 max      280434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280434
Ave neighs/atom = 70.108500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.07019718719, Press = -2.11068558704875
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -13093.368   -13093.368   -13263.814   -13263.814    329.74046    329.74046    67579.805    67579.805   -905.00901   -905.00901 
   20000   -13084.849   -13084.849   -13257.992   -13257.992    334.95568    334.95568    67489.934    67489.934    550.78504    550.78504 
Loop time of 139.367 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.620 ns/day, 38.713 hours/ns, 7.175 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.92     | 138.92     | 138.92     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05587    | 0.05587    | 0.05587    |   0.0 |  0.04
Output  | 0.00011259 | 0.00011259 | 0.00011259 |   0.0 |  0.00
Modify  | 0.33804    | 0.33804    | 0.33804    |   0.0 |  0.24
Other   |            | 0.05718    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279436.0 ave      279436 max      279436 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279436
Ave neighs/atom = 69.859000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.106187907881, Press = 4.54520201363144
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13084.849   -13084.849   -13257.992   -13257.992    334.95568    334.95568    67489.934    67489.934    550.78504    550.78504 
   21000   -13089.797   -13089.797   -13261.997   -13261.997    333.13235    333.13235    67508.982    67508.982    125.66659    125.66659 
Loop time of 141.192 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.612 ns/day, 39.220 hours/ns, 7.083 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 140.74     | 140.74     | 140.74     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.055088   | 0.055088   | 0.055088   |   0.0 |  0.04
Output  | 0.0001793  | 0.0001793  | 0.0001793  |   0.0 |  0.00
Modify  | 0.34052    | 0.34052    | 0.34052    |   0.0 |  0.24
Other   |            | 0.0546     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280084.0 ave      280084 max      280084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280084
Ave neighs/atom = 70.021000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.067188842881, Press = -2.04361275696057
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13089.797   -13089.797   -13261.997   -13261.997    333.13235    333.13235    67508.982    67508.982    125.66659    125.66659 
   22000   -13088.911   -13088.911   -13263.432   -13263.432     337.6236     337.6236    67562.216    67562.216   -596.46437   -596.46437 
Loop time of 139.72 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.28     | 139.28     | 139.28     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052971   | 0.052971   | 0.052971   |   0.0 |  0.04
Output  | 0.00010291 | 0.00010291 | 0.00010291 |   0.0 |  0.00
Modify  | 0.33274    | 0.33274    | 0.33274    |   0.0 |  0.24
Other   |            | 0.05327    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280052.0 ave      280052 max      280052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280052
Ave neighs/atom = 70.013000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.198502965754, Press = 0.875584374061556
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13088.911   -13088.911   -13263.432   -13263.432     337.6236     337.6236    67562.216    67562.216   -596.46437   -596.46437 
   23000   -13088.823   -13088.823   -13261.219   -13261.219    333.51103    333.51103    67505.727    67505.727    160.51223    160.51223 
Loop time of 143.067 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.604 ns/day, 39.741 hours/ns, 6.990 timesteps/s
99.3% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.62     | 142.62     | 142.62     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054051   | 0.054051   | 0.054051   |   0.0 |  0.04
Output  | 0.00010065 | 0.00010065 | 0.00010065 |   0.0 |  0.00
Modify  | 0.34108    | 0.34108    | 0.34108    |   0.0 |  0.24
Other   |            | 0.05192    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279670.0 ave      279670 max      279670 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279670
Ave neighs/atom = 69.917500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.31798378554, Press = -0.353719917441795
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13088.823   -13088.823   -13261.219   -13261.219    333.51103    333.51103    67505.727    67505.727    160.51223    160.51223 
   24000   -13092.564   -13092.564   -13264.067   -13264.067    331.78397    331.78397    67576.535    67576.535   -835.76492   -835.76492 
Loop time of 142.613 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.606 ns/day, 39.615 hours/ns, 7.012 timesteps/s
99.5% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 142.17     | 142.17     | 142.17     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053373   | 0.053373   | 0.053373   |   0.0 |  0.04
Output  | 0.00010171 | 0.00010171 | 0.00010171 |   0.0 |  0.00
Modify  | 0.33853    | 0.33853    | 0.33853    |   0.0 |  0.24
Other   |            | 0.05137    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279902.0 ave      279902 max      279902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279902
Ave neighs/atom = 69.975500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.38278800851, Press = -0.0382255470025029
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13092.564   -13092.564   -13264.067   -13264.067    331.78397    331.78397    67576.535    67576.535   -835.76492   -835.76492 
   25000   -13087.599   -13087.599    -13259.85    -13259.85    333.23222    333.23222    67369.857    67369.857    1767.5702    1767.5702 
Loop time of 143.568 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.602 ns/day, 39.880 hours/ns, 6.965 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 143.11     | 143.11     | 143.11     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.054845   | 0.054845   | 0.054845   |   0.0 |  0.04
Output  | 0.00011898 | 0.00011898 | 0.00011898 |   0.0 |  0.00
Modify  | 0.34804    | 0.34804    | 0.34804    |   0.0 |  0.24
Other   |            | 0.05462    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279708.0 ave      279708 max      279708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279708
Ave neighs/atom = 69.927000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.303038201018, Press = 0.938746931062569
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13087.599   -13087.599    -13259.85    -13259.85    333.23222    333.23222    67369.857    67369.857    1767.5702    1767.5702 
   26000   -13091.237   -13091.237   -13260.684   -13260.684     327.8059     327.8059    67607.104    67607.104   -1039.7545   -1039.7545 
Loop time of 143.69 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.601 ns/day, 39.914 hours/ns, 6.959 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 143.23     | 143.23     | 143.23     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053785   | 0.053785   | 0.053785   |   0.0 |  0.04
Output  | 0.00017004 | 0.00017004 | 0.00017004 |   0.0 |  0.00
Modify  | 0.35583    | 0.35583    | 0.35583    |   0.0 |  0.25
Other   |            | 0.05266    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280680.0 ave      280680 max      280680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280680
Ave neighs/atom = 70.170000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.329713949235, Press = -1.36905593307624
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13091.237   -13091.237   -13260.684   -13260.684     327.8059     327.8059    67607.104    67607.104   -1039.7545   -1039.7545 
   27000   -13083.911   -13083.911   -13255.694   -13255.694    332.32579    332.32579    67488.475    67488.475    799.34006    799.34006 
Loop time of 140.619 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.614 ns/day, 39.061 hours/ns, 7.111 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 140.18     | 140.18     | 140.18     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053033   | 0.053033   | 0.053033   |   0.0 |  0.04
Output  | 0.00011808 | 0.00011808 | 0.00011808 |   0.0 |  0.00
Modify  | 0.33568    | 0.33568    | 0.33568    |   0.0 |  0.24
Other   |            | 0.05275    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279046.0 ave      279046 max      279046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279046
Ave neighs/atom = 69.761500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.421688749003, Press = 1.35506731453465
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13083.911   -13083.911   -13255.694   -13255.694    332.32579    332.32579    67488.475    67488.475    799.34006    799.34006 
   28000   -13085.197   -13085.197   -13259.108   -13259.108    336.44279    336.44279    67563.808    67563.808   -325.06161   -325.06161 
Loop time of 141.37 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.611 ns/day, 39.269 hours/ns, 7.074 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 140.92     | 140.92     | 140.92     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05421    | 0.05421    | 0.05421    |   0.0 |  0.04
Output  | 0.00014556 | 0.00014556 | 0.00014556 |   0.0 |  0.00
Modify  | 0.33892    | 0.33892    | 0.33892    |   0.0 |  0.24
Other   |            | 0.05207    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279988.0 ave      279988 max      279988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279988
Ave neighs/atom = 69.997000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.485767590707, Press = -1.19698265848543
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13085.197   -13085.197   -13259.108   -13259.108    336.44279    336.44279    67563.808    67563.808   -325.06161   -325.06161 
   29000   -13088.037   -13088.037   -13262.787   -13262.787    338.06525    338.06525    67518.061    67518.061   -19.145191   -19.145191 
Loop time of 139.615 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.18     | 139.18     | 139.18     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052596   | 0.052596   | 0.052596   |   0.0 |  0.04
Output  | 0.00010609 | 0.00010609 | 0.00010609 |   0.0 |  0.00
Modify  | 0.33255    | 0.33255    | 0.33255    |   0.0 |  0.24
Other   |            | 0.05135    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279374.0 ave      279374 max      279374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279374
Ave neighs/atom = 69.843500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.591906277266, Press = 1.21846136321072
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13088.037   -13088.037   -13262.787   -13262.787    338.06525    338.06525    67518.061    67518.061   -19.145191   -19.145191 
   30000   -13082.297   -13082.297   -13257.016   -13257.016    338.00549    338.00549     67543.39     67543.39    75.465143    75.465143 
Loop time of 140.275 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.616 ns/day, 38.965 hours/ns, 7.129 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.84     | 139.84     | 139.84     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052468   | 0.052468   | 0.052468   |   0.0 |  0.04
Output  | 0.00010529 | 0.00010529 | 0.00010529 |   0.0 |  0.00
Modify  | 0.33115    | 0.33115    | 0.33115    |   0.0 |  0.24
Other   |            | 0.04963    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279738.0 ave      279738 max      279738 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279738
Ave neighs/atom = 69.934500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.635600440155, Press = -1.46202203406763
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13082.297   -13082.297   -13257.016   -13257.016    338.00549    338.00549     67543.39     67543.39    75.465143    75.465143 
   31000   -13089.946   -13089.946   -13260.305   -13260.305    329.57155    329.57155    67626.734    67626.734   -1138.5617   -1138.5617 
Loop time of 138.024 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.59     | 137.59     | 137.59     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052634   | 0.052634   | 0.052634   |   0.0 |  0.04
Output  | 0.0001138  | 0.0001138  | 0.0001138  |   0.0 |  0.00
Modify  | 0.32859    | 0.32859    | 0.32859    |   0.0 |  0.24
Other   |            | 0.05047    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279342.0 ave      279342 max      279342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279342
Ave neighs/atom = 69.835500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.686531868827, Press = 2.59586887687498
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -13089.946   -13089.946   -13260.305   -13260.305    329.57155    329.57155    67626.734    67626.734   -1138.5617   -1138.5617 
   32000   -13086.064   -13086.064   -13262.491   -13262.491    341.31017    341.31017      67433.3      67433.3    972.67598    972.67598 
Loop time of 136.508 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.633 ns/day, 37.919 hours/ns, 7.326 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.08     | 136.08     | 136.08     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051738   | 0.051738   | 0.051738   |   0.0 |  0.04
Output  | 0.00011618 | 0.00011618 | 0.00011618 |   0.0 |  0.00
Modify  | 0.32487    | 0.32487    | 0.32487    |   0.0 |  0.24
Other   |            | 0.04982    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5839.00 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      278952.0 ave      278952 max      278952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278952
Ave neighs/atom = 69.738000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.691758730102, Press = -0.80225405198801
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13086.064   -13086.064   -13262.491   -13262.491    341.31017    341.31017      67433.3      67433.3    972.67598    972.67598 
   33000   -13084.501   -13084.501   -13255.745   -13255.745    331.28284    331.28284    67633.397    67633.397   -827.77304   -827.77304 
Loop time of 137.39 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.629 ns/day, 38.164 hours/ns, 7.279 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.96     | 136.96     | 136.96     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051522   | 0.051522   | 0.051522   |   0.0 |  0.04
Output  | 0.00011692 | 0.00011692 | 0.00011692 |   0.0 |  0.00
Modify  | 0.32595    | 0.32595    | 0.32595    |   0.0 |  0.24
Other   |            | 0.04977    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5839.00 ave        5839 max        5839 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280716.0 ave      280716 max      280716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280716
Ave neighs/atom = 70.179000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.765546133618, Press = 0.268559041180957
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -13084.501   -13084.501   -13255.745   -13255.745    331.28284    331.28284    67633.397    67633.397   -827.77304   -827.77304 
   34000   -13086.951   -13086.951   -13259.505   -13259.505    333.81684    333.81684     67460.76     67460.76    833.63945    833.63945 
Loop time of 138.523 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.624 ns/day, 38.479 hours/ns, 7.219 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.09     | 138.09     | 138.09     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05176    | 0.05176    | 0.05176    |   0.0 |  0.04
Output  | 0.00010893 | 0.00010893 | 0.00010893 |   0.0 |  0.00
Modify  | 0.32927    | 0.32927    | 0.32927    |   0.0 |  0.24
Other   |            | 0.04932    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      278680.0 ave      278680 max      278680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278680
Ave neighs/atom = 69.670000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.792216562792, Press = 0.178234718772438
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -13086.951   -13086.951   -13259.505   -13259.505    333.81684    333.81684     67460.76     67460.76    833.63945    833.63945 
   35000   -13088.412   -13088.412   -13258.464   -13258.464    328.97614    328.97614    67592.226    67592.226    -673.5012    -673.5012 
Loop time of 140.518 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.615 ns/day, 39.033 hours/ns, 7.117 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 140.08     | 140.08     | 140.08     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052893   | 0.052893   | 0.052893   |   0.0 |  0.04
Output  | 0.00010255 | 0.00010255 | 0.00010255 |   0.0 |  0.00
Modify  | 0.33475    | 0.33475    | 0.33475    |   0.0 |  0.24
Other   |            | 0.04992    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280500.0 ave      280500 max      280500 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280500
Ave neighs/atom = 70.125000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.872739485003, Press = -0.192928471996662
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13088.412   -13088.412   -13258.464   -13258.464    328.97614    328.97614    67592.226    67592.226    -673.5012    -673.5012 
   36000   -13082.171   -13082.171   -13257.023   -13257.023    338.26168    338.26168    67479.678    67479.678    833.54542    833.54542 
Loop time of 136.82 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.631 ns/day, 38.006 hours/ns, 7.309 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.39     | 136.39     | 136.39     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052034   | 0.052034   | 0.052034   |   0.0 |  0.04
Output  | 0.00010561 | 0.00010561 | 0.00010561 |   0.0 |  0.00
Modify  | 0.32588    | 0.32588    | 0.32588    |   0.0 |  0.24
Other   |            | 0.05028    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279338.0 ave      279338 max      279338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279338
Ave neighs/atom = 69.834500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.919549855424, Press = 1.14122483540033
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -13082.171   -13082.171   -13257.023   -13257.023    338.26168    338.26168    67479.678    67479.678    833.54542    833.54542 
   37000   -13091.501   -13091.501   -13262.197   -13262.197    330.22297    330.22297    67593.669    67593.669   -870.73368   -870.73368 
Loop time of 137.424 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.629 ns/day, 38.173 hours/ns, 7.277 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.99     | 136.99     | 136.99     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052234   | 0.052234   | 0.052234   |   0.0 |  0.04
Output  | 0.0001182  | 0.0001182  | 0.0001182  |   0.0 |  0.00
Modify  | 0.32645    | 0.32645    | 0.32645    |   0.0 |  0.24
Other   |            | 0.05112    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280034.0 ave      280034 max      280034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280034
Ave neighs/atom = 70.008500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.928732051567, Press = -1.8148817856267
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -13091.501   -13091.501   -13262.197   -13262.197    330.22297    330.22297    67593.669    67593.669   -870.73368   -870.73368 
   38000   -13086.321   -13086.321   -13257.308   -13257.308    330.78479    330.78479    67528.192    67528.192    180.43123    180.43123 
Loop time of 139.77 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.618 ns/day, 38.825 hours/ns, 7.155 timesteps/s
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.34     | 139.34     | 139.34     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052336   | 0.052336   | 0.052336   |   0.0 |  0.04
Output  | 0.0001061  | 0.0001061  | 0.0001061  |   0.0 |  0.00
Modify  | 0.33218    | 0.33218    | 0.33218    |   0.0 |  0.24
Other   |            | 0.0498     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279452.0 ave      279452 max      279452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279452
Ave neighs/atom = 69.863000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.919775538201, Press = 1.53782100735187
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -13086.321   -13086.321   -13257.308   -13257.308    330.78479    330.78479    67528.192    67528.192    180.43123    180.43123 
   39000    -13086.48    -13086.48   -13259.643   -13259.643    334.99564    334.99564    67519.985    67519.985    121.14047    121.14047 
Loop time of 139.622 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.619 ns/day, 38.784 hours/ns, 7.162 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 139.19     | 139.19     | 139.19     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052449   | 0.052449   | 0.052449   |   0.0 |  0.04
Output  | 0.00010915 | 0.00010915 | 0.00010915 |   0.0 |  0.00
Modify  | 0.33273    | 0.33273    | 0.33273    |   0.0 |  0.24
Other   |            | 0.04952    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279414.0 ave      279414 max      279414 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279414
Ave neighs/atom = 69.853500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.907021564669, Press = -0.594544884902704
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000    -13086.48    -13086.48   -13259.643   -13259.643    334.99564    334.99564    67519.985    67519.985    121.14047    121.14047 
   40000   -13088.618   -13088.618   -13258.661   -13258.661    328.95979    328.95979    67548.001    67548.001   -172.27233   -172.27233 
Loop time of 138.775 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.623 ns/day, 38.549 hours/ns, 7.206 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 138.33     | 138.33     | 138.33     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052533   | 0.052533   | 0.052533   |   0.0 |  0.04
Output  | 0.00010349 | 0.00010349 | 0.00010349 |   0.0 |  0.00
Modify  | 0.34195    | 0.34195    | 0.34195    |   0.0 |  0.25
Other   |            | 0.05072    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279434.0 ave      279434 max      279434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279434
Ave neighs/atom = 69.858500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.879360000449, Press = 0.851572651297133
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -13088.618   -13088.618   -13258.661   -13258.661    328.95979    328.95979    67548.001    67548.001   -172.27233   -172.27233 
   41000   -13092.997   -13092.997   -13262.685   -13262.685    328.27435    328.27435    67458.443    67458.443    517.10288    517.10288 
Loop time of 136.967 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.631 ns/day, 38.046 hours/ns, 7.301 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.54     | 136.54     | 136.54     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051912   | 0.051912   | 0.051912   |   0.0 |  0.04
Output  | 0.00014249 | 0.00014249 | 0.00014249 |   0.0 |  0.00
Modify  | 0.32508    | 0.32508    | 0.32508    |   0.0 |  0.24
Other   |            | 0.04987    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279552.0 ave      279552 max      279552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279552
Ave neighs/atom = 69.888000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.904488922477, Press = -0.464143031749459
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -13092.997   -13092.997   -13262.685   -13262.685    328.27435    328.27435    67458.443    67458.443    517.10288    517.10288 
   42000   -13087.081   -13087.081   -13255.086   -13255.086     325.0172     325.0172     67643.53     67643.53   -946.33318   -946.33318 
Loop time of 137.609 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.628 ns/day, 38.225 hours/ns, 7.267 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 137.18     | 137.18     | 137.18     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052094   | 0.052094   | 0.052094   |   0.0 |  0.04
Output  | 0.00023133 | 0.00023133 | 0.00023133 |   0.0 |  0.00
Modify  | 0.32711    | 0.32711    | 0.32711    |   0.0 |  0.24
Other   |            | 0.05079    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5840.00 ave        5840 max        5840 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280496.0 ave      280496 max      280496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280496
Ave neighs/atom = 70.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 = 332.871282783015, Press = 0.774797763575146
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -13087.081   -13087.081   -13255.086   -13255.086     325.0172     325.0172     67643.53     67643.53   -946.33318   -946.33318 
   43000   -13090.113   -13090.113   -13260.785   -13260.785    330.17735    330.17735    67380.212    67380.212    1617.6962    1617.6962 
Loop time of 136.022 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.635 ns/day, 37.784 hours/ns, 7.352 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.59     | 135.59     | 135.59     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05174    | 0.05174    | 0.05174    |   0.0 |  0.04
Output  | 0.00010336 | 0.00010336 | 0.00010336 |   0.0 |  0.00
Modify  | 0.32859    | 0.32859    | 0.32859    |   0.0 |  0.24
Other   |            | 0.05572    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      278720.0 ave      278720 max      278720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278720
Ave neighs/atom = 69.680000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.872225355091, Press = -0.00544585492716125
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -13090.113   -13090.113   -13260.785   -13260.785    330.17735    330.17735    67380.212    67380.212    1617.6962    1617.6962 
   44000   -13084.932   -13084.932   -13259.054   -13259.054    336.85074    336.85074    67635.735    67635.735   -1169.9377   -1169.9377 
Loop time of 135.762 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.636 ns/day, 37.712 hours/ns, 7.366 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.34     | 135.34     | 135.34     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.05157    | 0.05157    | 0.05157    |   0.0 |  0.04
Output  | 0.00010987 | 0.00010987 | 0.00010987 |   0.0 |  0.00
Modify  | 0.32234    | 0.32234    | 0.32234    |   0.0 |  0.24
Other   |            | 0.05061    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      281082.0 ave      281082 max      281082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281082
Ave neighs/atom = 70.270500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.875748207983, Press = -0.176116736982764
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -13084.932   -13084.932   -13259.054   -13259.054    336.85074    336.85074    67635.735    67635.735   -1169.9377   -1169.9377 
   45000   -13090.092   -13090.092   -13258.073   -13258.073    324.96935    324.96935    67451.877    67451.877    979.96178    979.96178 
Loop time of 135.102 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.640 ns/day, 37.528 hours/ns, 7.402 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    | 134.68     | 134.68     | 134.68     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051361   | 0.051361   | 0.051361   |   0.0 |  0.04
Output  | 0.00010943 | 0.00010943 | 0.00010943 |   0.0 |  0.00
Modify  | 0.32275    | 0.32275    | 0.32275    |   0.0 |  0.24
Other   |            | 0.05089    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      278608.0 ave      278608 max      278608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278608
Ave neighs/atom = 69.652000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.85354918939, Press = 0.759490306586925
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -13090.092   -13090.092   -13258.073   -13258.073    324.96935    324.96935    67451.877    67451.877    979.96178    979.96178 
   46000   -13085.951   -13085.951   -13258.386   -13258.386    333.58727    333.58727    67587.081    67587.081   -501.99957   -501.99957 
Loop time of 136.569 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.633 ns/day, 37.936 hours/ns, 7.322 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.14     | 136.14     | 136.14     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051596   | 0.051596   | 0.051596   |   0.0 |  0.04
Output  | 0.00016335 | 0.00016335 | 0.00016335 |   0.0 |  0.00
Modify  | 0.3241     | 0.3241     | 0.3241     |   0.0 |  0.24
Other   |            | 0.05167    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280234.0 ave      280234 max      280234 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280234
Ave neighs/atom = 70.058500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.824359382452, Press = -0.53870983356591
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -13085.951   -13085.951   -13258.386   -13258.386    333.58727    333.58727    67587.081    67587.081   -501.99957   -501.99957 
   47000   -13090.311   -13090.311   -13262.752   -13262.752    333.59909    333.59909    67516.445    67516.445   -59.114305   -59.114305 
Loop time of 136.676 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.632 ns/day, 37.965 hours/ns, 7.317 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.25     | 136.25     | 136.25     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051627   | 0.051627   | 0.051627   |   0.0 |  0.04
Output  | 0.00011521 | 0.00011521 | 0.00011521 |   0.0 |  0.00
Modify  | 0.327      | 0.327      | 0.327      |   0.0 |  0.24
Other   |            | 0.05193    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      278984.0 ave      278984 max      278984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278984
Ave neighs/atom = 69.746000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.798939945611, Press = 1.16275540735575
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -13090.311   -13090.311   -13262.752   -13262.752    333.59909    333.59909    67516.445    67516.445   -59.114305   -59.114305 
   48000   -13086.816   -13086.816   -13259.271   -13259.271    333.62574    333.62574     67512.94     67512.94    229.37576    229.37576 
Loop time of 136.161 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.635 ns/day, 37.823 hours/ns, 7.344 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.73     | 135.73     | 135.73     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051943   | 0.051943   | 0.051943   |   0.0 |  0.04
Output  | 0.00010427 | 0.00010427 | 0.00010427 |   0.0 |  0.00
Modify  | 0.32636    | 0.32636    | 0.32636    |   0.0 |  0.24
Other   |            | 0.05241    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279942.0 ave      279942 max      279942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279942
Ave neighs/atom = 69.985500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.81097671329, Press = -0.513510582689135
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -13086.816   -13086.816   -13259.271   -13259.271    333.62574    333.62574     67512.94     67512.94    229.37576    229.37576 
   49000   -13094.141   -13094.141   -13262.874   -13262.874    326.42492    326.42492    67527.597    67527.597   -224.73821   -224.73821 
Loop time of 136.108 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.635 ns/day, 37.808 hours/ns, 7.347 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.68     | 135.68     | 135.68     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.052027   | 0.052027   | 0.052027   |   0.0 |  0.04
Output  | 0.00010178 | 0.00010178 | 0.00010178 |   0.0 |  0.00
Modify  | 0.32705    | 0.32705    | 0.32705    |   0.0 |  0.24
Other   |            | 0.05321    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279730.0 ave      279730 max      279730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279730
Ave neighs/atom = 69.932500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.771527619512, Press = 0.851779873596033
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -13094.141   -13094.141   -13262.874   -13262.874    326.42492    326.42492    67527.597    67527.597   -224.73821   -224.73821 
   50000   -13084.415   -13084.415   -13258.937   -13258.937    337.62404    337.62404    67489.186    67489.186    587.26924    587.26924 
Loop time of 136.843 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.631 ns/day, 38.012 hours/ns, 7.308 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.42     | 136.42     | 136.42     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051586   | 0.051586   | 0.051586   |   0.0 |  0.04
Output  | 0.00010194 | 0.00010194 | 0.00010194 |   0.0 |  0.00
Modify  | 0.32535    | 0.32535    | 0.32535    |   0.0 |  0.24
Other   |            | 0.04985    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280070.0 ave      280070 max      280070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280070
Ave neighs/atom = 70.017500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.766989228227, Press = -0.573114139794005
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -13084.415   -13084.415   -13258.937   -13258.937    337.62404    337.62404    67489.186    67489.186    587.26924    587.26924 
   51000   -13086.924   -13086.924   -13260.052   -13260.052    334.92737    334.92737    67676.064    67676.064   -1561.0594   -1561.0594 
Loop time of 136.46 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.633 ns/day, 37.906 hours/ns, 7.328 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 136.03     | 136.03     | 136.03     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051824   | 0.051824   | 0.051824   |   0.0 |  0.04
Output  | 0.00011784 | 0.00011784 | 0.00011784 |   0.0 |  0.00
Modify  | 0.32342    | 0.32342    | 0.32342    |   0.0 |  0.24
Other   |            | 0.05091    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280026.0 ave      280026 max      280026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280026
Ave neighs/atom = 70.006500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.776111873923, Press = 0.790454028341095
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -13086.924   -13086.924   -13260.052   -13260.052    334.92737    334.92737    67676.064    67676.064   -1561.0594   -1561.0594 
   52000    -13087.29    -13087.29   -13261.076   -13261.076    336.20002    336.20002    67435.461    67435.461    1040.2801    1040.2801 
Loop time of 134.355 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.643 ns/day, 37.321 hours/ns, 7.443 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.93     | 133.93     | 133.93     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051561   | 0.051561   | 0.051561   |   0.0 |  0.04
Output  | 9.2607e-05 | 9.2607e-05 | 9.2607e-05 |   0.0 |  0.00
Modify  | 0.32046    | 0.32046    | 0.32046    |   0.0 |  0.24
Other   |            | 0.0506     |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      278414.0 ave      278414 max      278414 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278414
Ave neighs/atom = 69.603500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.796635713722, Press = 0.0361695966875299
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000    -13087.29    -13087.29   -13261.076   -13261.076    336.20002    336.20002    67435.461    67435.461    1040.2801    1040.2801 
   53000   -13087.784   -13087.784   -13258.084   -13258.084    329.45792    329.45792    67583.316    67583.316   -510.09251   -510.09251 
Loop time of 135.715 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.637 ns/day, 37.698 hours/ns, 7.368 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 135.29     | 135.29     | 135.29     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051322   | 0.051322   | 0.051322   |   0.0 |  0.04
Output  | 0.00010024 | 0.00010024 | 0.00010024 |   0.0 |  0.00
Modify  | 0.32264    | 0.32264    | 0.32264    |   0.0 |  0.24
Other   |            | 0.05122    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      280430.0 ave      280430 max      280430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280430
Ave neighs/atom = 70.107500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.831332545778, Press = -0.00140804559959034
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -13087.784   -13087.784   -13258.084   -13258.084    329.45792    329.45792    67583.316    67583.316   -510.09251   -510.09251 
   54000   -13087.014   -13087.014   -13256.331   -13256.331     327.5563     327.5563    67480.227    67480.227    758.38817    758.38817 
Loop time of 133.508 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.647 ns/day, 37.086 hours/ns, 7.490 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.09     | 133.09     | 133.09     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050994   | 0.050994   | 0.050994   |   0.0 |  0.04
Output  | 0.00010166 | 0.00010166 | 0.00010166 |   0.0 |  0.00
Modify  | 0.31718    | 0.31718    | 0.31718    |   0.0 |  0.24
Other   |            | 0.05142    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279300.0 ave      279300 max      279300 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279300
Ave neighs/atom = 69.825000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.850459977388, Press = 0.502949724811045
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -13087.014   -13087.014   -13256.331   -13256.331     327.5563     327.5563    67480.227    67480.227    758.38817    758.38817 
   55000   -13082.059   -13082.059   -13258.671   -13258.671    341.66664    341.66664    67593.897    67593.897   -538.15149   -538.15149 
Loop time of 133.957 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.645 ns/day, 37.210 hours/ns, 7.465 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.54     | 133.54     | 133.54     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050775   | 0.050775   | 0.050775   |   0.0 |  0.04
Output  | 9.6738e-05 | 9.6738e-05 | 9.6738e-05 |   0.0 |  0.00
Modify  | 0.31832    | 0.31832    | 0.31832    |   0.0 |  0.24
Other   |            | 0.05082    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279804.0 ave      279804 max      279804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279804
Ave neighs/atom = 69.951000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.868033412935, Press = -0.35449835636113
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -13082.059   -13082.059   -13258.671   -13258.671    341.66664    341.66664    67593.897    67593.897   -538.15149   -538.15149 
   56000   -13088.037   -13088.037   -13258.389   -13258.389    329.55784    329.55784    67511.751    67511.751     277.1863     277.1863 
Loop time of 133.529 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.647 ns/day, 37.091 hours/ns, 7.489 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.11     | 133.11     | 133.11     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051004   | 0.051004   | 0.051004   |   0.0 |  0.04
Output  | 9.6684e-05 | 9.6684e-05 | 9.6684e-05 |   0.0 |  0.00
Modify  | 0.31768    | 0.31768    | 0.31768    |   0.0 |  0.24
Other   |            | 0.05081    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      278974.0 ave      278974 max      278974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278974
Ave neighs/atom = 69.743500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.913816966265, Press = 1.16457099743703
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -13088.037   -13088.037   -13258.389   -13258.389    329.55784    329.55784    67511.751    67511.751     277.1863     277.1863 
   57000   -13083.007   -13083.007   -13258.826   -13258.826    340.13273    340.13273    67494.232    67494.232    493.15283    493.15283 
Loop time of 132.056 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.654 ns/day, 36.682 hours/ns, 7.573 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 131.64     | 131.64     | 131.64     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051003   | 0.051003   | 0.051003   |   0.0 |  0.04
Output  | 0.00010256 | 0.00010256 | 0.00010256 |   0.0 |  0.00
Modify  | 0.3157     | 0.3157     | 0.3157     |   0.0 |  0.24
Other   |            | 0.05286    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5837.00 ave        5837 max        5837 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279392.0 ave      279392 max      279392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279392
Ave neighs/atom = 69.848000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.930668732986, Press = -1.14913904768401
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -13083.007   -13083.007   -13258.826   -13258.826    340.13273    340.13273    67494.232    67494.232    493.15283    493.15283 
   58000    -13089.53    -13089.53   -13260.262   -13260.262    330.29196    330.29196     67571.35     67571.35   -509.06977   -509.06977 
Loop time of 133.44 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.647 ns/day, 37.067 hours/ns, 7.494 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 133.02     | 133.02     | 133.02     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.051105   | 0.051105   | 0.051105   |   0.0 |  0.04
Output  | 9.9924e-05 | 9.9924e-05 | 9.9924e-05 |   0.0 |  0.00
Modify  | 0.31853    | 0.31853    | 0.31853    |   0.0 |  0.24
Other   |            | 0.05206    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279892.0 ave      279892 max      279892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279892
Ave neighs/atom = 69.973000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.974504600702, Press = 0.699416370599044
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.232 | 4.232 | 4.232 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000    -13089.53    -13089.53   -13260.262   -13260.262    330.29196    330.29196     67571.35     67571.35   -509.06977   -509.06977 
   59000   -13084.816   -13084.816   -13257.361   -13257.361    333.80169    333.80169    67468.566    67468.566    809.12998    809.12998 
Loop time of 128.214 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.81     | 127.81     | 127.81     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04942    | 0.04942    | 0.04942    |   0.0 |  0.04
Output  | 8.3971e-05 | 8.3971e-05 | 8.3971e-05 |   0.0 |  0.00
Modify  | 0.30282    | 0.30282    | 0.30282    |   0.0 |  0.24
Other   |            | 0.05212    |            |       |  0.04

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5841.00 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279064.0 ave      279064 max      279064 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279064
Ave neighs/atom = 69.766000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
67532.6748369448

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0