# 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.005 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_JeongParkDo_2018_PdAl__MO_616482358807_001
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_616482358807_001#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.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 357.539 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.242 ns/day, 99.316 hours/ns, 2.797 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    | 356.57     | 356.57     | 356.57     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15365    | 0.15365    | 0.15365    |   0.0 |  0.04
Output  | 0.00022763 | 0.00022763 | 0.00022763 |   0.0 |  0.00
Modify  | 0.71669    | 0.71669    | 0.71669    |   0.0 |  0.20
Other   |            | 0.1003     |            |       |  0.03

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.31245    218.31245 
Loop time of 331.874 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.187 hours/ns, 3.013 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    | 330.99     | 330.99     | 330.99     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14556    | 0.14556    | 0.14556    |   0.0 |  0.04
Output  | 0.00022436 | 0.00022436 | 0.00022436 |   0.0 |  0.00
Modify  | 0.64267    | 0.64267    | 0.64267    |   0.0 |  0.19
Other   |            | 0.09427    |            |       |  0.03

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.31245    218.31245 
    3000   -13081.147   -13081.147   -13252.397   -13252.397    331.29504    331.29504    67556.434    67556.434    222.99509    222.99509 
Loop time of 353.716 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.244 ns/day, 98.255 hours/ns, 2.827 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    | 352.76     | 352.76     | 352.76     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15258    | 0.15258    | 0.15258    |   0.0 |  0.04
Output  | 0.00025262 | 0.00025262 | 0.00025262 |   0.0 |  0.00
Modify  | 0.70425    | 0.70425    | 0.70425    |   0.0 |  0.20
Other   |            | 0.1002     |            |       |  0.03

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.99509    222.99509 
    4000   -13091.546   -13091.546   -13261.599   -13261.599    328.97885    328.97885    67536.983    67536.983   -234.21553   -234.21553 
Loop time of 330.934 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.926 hours/ns, 3.022 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    | 330.05     | 330.05     | 330.05     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14541    | 0.14541    | 0.14541    |   0.0 |  0.04
Output  | 0.00025488 | 0.00025488 | 0.00025488 |   0.0 |  0.00
Modify  | 0.64011    | 0.64011    | 0.64011    |   0.0 |  0.19
Other   |            | 0.0934     |            |       |  0.03

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.21553   -234.21553 
    5000   -13085.409   -13085.409   -13259.522   -13259.522    336.83331    336.83331    67526.848    67526.848    43.342877    43.342877 
Loop time of 331.76 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.260 ns/day, 92.155 hours/ns, 3.014 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    | 330.88     | 330.88     | 330.88     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14391    | 0.14391    | 0.14391    |   0.0 |  0.04
Output  | 0.0001798  | 0.0001798  | 0.0001798  |   0.0 |  0.00
Modify  | 0.64476    | 0.64476    | 0.64476    |   0.0 |  0.19
Other   |            | 0.09374    |            |       |  0.03

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.076764452366, Press = -155.577772283408
next a
jump SELF top
variable a loop 2000
run 1000
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.83331    336.83331    67526.848    67526.848    43.342877    43.342877 
    6000   -13087.077   -13087.077   -13259.932   -13259.932    334.40005    334.40005    67566.148    67566.148   -412.00232   -412.00232 
Loop time of 330.921 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 91.923 hours/ns, 3.022 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    | 330.02     | 330.02     | 330.02     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14363    | 0.14363    | 0.14363    |   0.0 |  0.04
Output  | 0.00017969 | 0.00017969 | 0.00017969 |   0.0 |  0.00
Modify  | 0.66305    | 0.66305    | 0.66305    |   0.0 |  0.20
Other   |            | 0.09344    |            |       |  0.03

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.721096295777, Press = 14.8609616309605
next a
jump SELF top
variable a loop 2000
run 1000
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.00232   -412.00232 
    7000   -13088.301   -13088.301   -13260.149   -13260.149    332.45281    332.45281    67451.203    67451.203    832.23778    832.23778 
Loop time of 331.475 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.261 ns/day, 92.076 hours/ns, 3.017 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    | 330.57     | 330.57     | 330.57     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1445     | 0.1445     | 0.1445     |   0.0 |  0.04
Output  | 0.0001806  | 0.0001806  | 0.0001806  |   0.0 |  0.00
Modify  | 0.6644     | 0.6644     | 0.6644     |   0.0 |  0.20
Other   |            | 0.09416    |            |       |  0.03

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.2072048357, Press = -20.0077084491081
next a
jump SELF top
variable a loop 2000
run 1000
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.45281    332.45281    67451.203    67451.203    832.23778    832.23778 
    8000   -13087.107   -13087.107   -13255.957   -13255.957    326.65257    326.65257     67669.13     67669.13   -1389.0263   -1389.0263 
Loop time of 333.187 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.259 ns/day, 92.552 hours/ns, 3.001 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 332.28     | 332.28     | 332.28     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14562    | 0.14562    | 0.14562    |   0.0 |  0.04
Output  | 0.00018472 | 0.00018472 | 0.00018472 |   0.0 |  0.00
Modify  | 0.66586    | 0.66586    | 0.66586    |   0.0 |  0.20
Other   |            | 0.09372    |            |       |  0.03

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.932388222818, Press = 6.96142285487547
next a
jump SELF top
variable a loop 2000
run 1000
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.0263   -1389.0263 
    9000   -13091.531   -13091.531   -13261.172   -13261.172    328.18288    328.18288    67428.825    67428.825    954.72905    954.72905 
Loop time of 359.399 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.240 ns/day, 99.833 hours/ns, 2.782 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    | 358.39     | 358.39     | 358.39     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15385    | 0.15385    | 0.15385    |   0.0 |  0.04
Output  | 0.00017854 | 0.00017854 | 0.00017854 |   0.0 |  0.00
Modify  | 0.75388    | 0.75388    | 0.75388    |   0.0 |  0.21
Other   |            | 0.1007     |            |       |  0.03

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.691169882067, Press = -1.64761690592323
next a
jump SELF top
variable a loop 2000
run 1000
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.172   -13261.172    328.18288    328.18288    67428.825    67428.825    954.72905    954.72905 
   10000   -13086.737   -13086.737   -13259.465   -13259.465     334.1552     334.1552    67589.821    67589.821   -722.64757   -722.64757 
Loop time of 376.33 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.536 hours/ns, 2.657 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    | 375.26     | 375.26     | 375.26     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15942    | 0.15942    | 0.15942    |   0.0 |  0.04
Output  | 0.00018278 | 0.00018278 | 0.00018278 |   0.0 |  0.00
Modify  | 0.8003     | 0.8003     | 0.8003     |   0.0 |  0.21
Other   |            | 0.1049     |            |       |  0.03

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.429301139656, Press = -1.63277834921327
next a
jump SELF top
variable a loop 2000
run 1000
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.1552     334.1552    67589.821    67589.821   -722.64757   -722.64757 
   11000   -13091.706   -13091.706   -13261.436   -13261.436    328.35509    328.35509    67470.023    67470.023     566.8094     566.8094 
Loop time of 375.732 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.370 hours/ns, 2.661 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    | 374.66     | 374.66     | 374.66     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16047    | 0.16047    | 0.16047    |   0.0 |  0.04
Output  | 0.00022889 | 0.00022889 | 0.00022889 |   0.0 |  0.00
Modify  | 0.80613    | 0.80613    | 0.80613    |   0.0 |  0.21
Other   |            | 0.1062     |            |       |  0.03

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.409156854869, Press = 1.39601327590321
next a
jump SELF top
variable a loop 2000
run 1000
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.8094     566.8094 
   12000   -13087.222   -13087.222   -13259.121   -13259.121    332.55076    332.55076    67574.858    67574.858   -420.90115   -420.90115 
Loop time of 379.654 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.459 hours/ns, 2.634 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    | 378.57     | 378.57     | 378.57     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16082    | 0.16082    | 0.16082    |   0.0 |  0.04
Output  | 0.00018435 | 0.00018435 | 0.00018435 |   0.0 |  0.00
Modify  | 0.81509    | 0.81509    | 0.81509    |   0.0 |  0.21
Other   |            | 0.1059     |            |       |  0.03

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.171938319284, Press = -3.21810151000863
next a
jump SELF top
variable a loop 2000
run 1000
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.55076    332.55076    67574.858    67574.858   -420.90115   -420.90115 
   13000   -13089.219   -13089.219    -13262.85    -13262.85    335.90106    335.90106    67490.851    67490.851     256.5616     256.5616 
Loop time of 369.954 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.765 hours/ns, 2.703 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    | 368.9      | 368.9      | 368.9      |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15788    | 0.15788    | 0.15788    |   0.0 |  0.04
Output  | 0.00022628 | 0.00022628 | 0.00022628 |   0.0 |  0.00
Modify  | 0.78965    | 0.78965    | 0.78965    |   0.0 |  0.21
Other   |            | 0.1045     |            |       |  0.03

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.233505499218, Press = 4.84645266646145
next a
jump SELF top
variable a loop 2000
run 1000
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.90106    335.90106    67490.851    67490.851     256.5616     256.5616 
   14000   -13086.705   -13086.705    -13259.71    -13259.71    334.68946    334.68946    67534.623    67534.623   -34.333772   -34.333772 
Loop time of 386.146 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.263 hours/ns, 2.590 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    | 385.04     | 385.04     | 385.04     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16348    | 0.16348    | 0.16348    |   0.0 |  0.04
Output  | 0.00023246 | 0.00023246 | 0.00023246 |   0.0 |  0.00
Modify  | 0.83043    | 0.83043    | 0.83043    |   0.0 |  0.22
Other   |            | 0.1074     |            |       |  0.03

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.168121553606, Press = -6.88489278715668
next a
jump SELF top
variable a loop 2000
run 1000
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.68946    334.68946    67534.623    67534.623   -34.333772   -34.333772 
   15000   -13091.208   -13091.208   -13258.398   -13258.398    323.44106    323.44106    67578.093    67578.093   -589.10683   -589.10683 
Loop time of 379.214 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.337 hours/ns, 2.637 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    | 378.14     | 378.14     | 378.14     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16089    | 0.16089    | 0.16089    |   0.0 |  0.04
Output  | 0.00058286 | 0.00058286 | 0.00058286 |   0.0 |  0.00
Modify  | 0.81162    | 0.81162    | 0.81162    |   0.0 |  0.21
Other   |            | 0.1049     |            |       |  0.03

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.262927163699, Press = 2.90772232785346
next a
jump SELF top
variable a loop 2000
run 1000
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.208   -13091.208   -13258.398   -13258.398    323.44106    323.44106    67578.093    67578.093   -589.10683   -589.10683 
   16000   -13084.306   -13084.306   -13260.263   -13260.263    340.40086    340.40086     67482.39     67482.39    557.23825    557.23825 
Loop time of 377.424 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.840 hours/ns, 2.650 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    | 376.35     | 376.35     | 376.35     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16104    | 0.16104    | 0.16104    |   0.0 |  0.04
Output  | 0.00017924 | 0.00017924 | 0.00017924 |   0.0 |  0.00
Modify  | 0.80899    | 0.80899    | 0.80899    |   0.0 |  0.21
Other   |            | 0.1051     |            |       |  0.03

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.251090801623, Press = -0.838706492872338
next a
jump SELF top
variable a loop 2000
run 1000
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.40086    340.40086     67482.39     67482.39    557.23825    557.23825 
   17000    -13091.93    -13091.93   -13262.393   -13262.393    329.77186    329.77186    67587.526    67587.526   -846.98002   -846.98002 
Loop time of 355.447 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.243 ns/day, 98.735 hours/ns, 2.813 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    | 354.45     | 354.45     | 354.45     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15345    | 0.15345    | 0.15345    |   0.0 |  0.04
Output  | 0.00018264 | 0.00018264 | 0.00018264 |   0.0 |  0.00
Modify  | 0.74135    | 0.74135    | 0.74135    |   0.0 |  0.21
Other   |            | 0.1007     |            |       |  0.03

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:      280254.0 ave      280254 max      280254 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280254
Ave neighs/atom = 70.063500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.156460040058, Press = 0.152761608919976
next a
jump SELF top
variable a loop 2000
run 1000
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.93    -13091.93   -13262.393   -13262.393    329.77186    329.77186    67587.526    67587.526   -846.98002   -846.98002 
   18000    -13086.45    -13086.45   -13260.154   -13260.154    336.04142    336.04142    67465.102    67465.102    708.19322    708.19322 
Loop time of 384.701 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.861 hours/ns, 2.599 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    | 383.6      | 383.6      | 383.6      |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16358    | 0.16358    | 0.16358    |   0.0 |  0.04
Output  | 0.00018057 | 0.00018057 | 0.00018057 |   0.0 |  0.00
Modify  | 0.82897    | 0.82897    | 0.82897    |   0.0 |  0.22
Other   |            | 0.1071     |            |       |  0.03

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:      279310.0 ave      279310 max      279310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279310
Ave neighs/atom = 69.827500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.183316200826, Press = 0.700679769178694
next a
jump SELF top
variable a loop 2000
run 1000
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.45    -13086.45   -13260.154   -13260.154    336.04142    336.04142    67465.102    67465.102    708.19322    708.19322 
   19000    -13093.38    -13093.38   -13263.823   -13263.823    329.73213    329.73213    67580.089    67580.089   -908.86446   -908.86446 
Loop time of 365.643 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.236 ns/day, 101.568 hours/ns, 2.735 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    | 364.61     | 364.61     | 364.61     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15567    | 0.15567    | 0.15567    |   0.0 |  0.04
Output  | 0.00018028 | 0.00018028 | 0.00018028 |   0.0 |  0.00
Modify  | 0.77103    | 0.77103    | 0.77103    |   0.0 |  0.21
Other   |            | 0.1026     |            |       |  0.03

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:      280432.0 ave      280432 max      280432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280432
Ave neighs/atom = 70.108000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.069593022077, Press = -2.11228383032915
next a
jump SELF top
variable a loop 2000
run 1000
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.38    -13093.38   -13263.823   -13263.823    329.73213    329.73213    67580.089    67580.089   -908.86446   -908.86446 
   20000    -13084.82    -13084.82   -13257.963   -13257.963    334.95867    334.95867    67491.353    67491.353    536.73328    536.73328 
Loop time of 371.742 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.232 ns/day, 103.262 hours/ns, 2.690 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    | 370.69     | 370.69     | 370.69     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15794    | 0.15794    | 0.15794    |   0.0 |  0.04
Output  | 0.00017678 | 0.00017678 | 0.00017678 |   0.0 |  0.00
Modify  | 0.79083    | 0.79083    | 0.79083    |   0.0 |  0.21
Other   |            | 0.1048     |            |       |  0.03

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.108703154144, Press = 4.53832425378187
next a
jump SELF top
variable a loop 2000
run 1000
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.82    -13084.82   -13257.963   -13257.963    334.95867    334.95867    67491.353    67491.353    536.73328    536.73328 
   21000   -13085.645   -13085.645   -13259.748   -13259.748    336.81328    336.81328    67521.503    67521.503    176.20187    176.20187 
Loop time of 369.775 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.715 hours/ns, 2.704 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    | 368.72     | 368.72     | 368.72     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15854    | 0.15854    | 0.15854    |   0.0 |  0.04
Output  | 0.00018003 | 0.00018003 | 0.00018003 |   0.0 |  0.00
Modify  | 0.78778    | 0.78778    | 0.78778    |   0.0 |  0.21
Other   |            | 0.1049     |            |       |  0.03

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:      280072.0 ave      280072 max      280072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280072
Ave neighs/atom = 70.018000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.089533805207, Press = -1.76578593171145
next a
jump SELF top
variable a loop 2000
run 1000
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   -13085.645   -13085.645   -13259.748   -13259.748    336.81328    336.81328    67521.503    67521.503    176.20187    176.20187 
   22000   -13082.133   -13082.133   -13259.764   -13259.764    343.63912    343.63912    67596.656    67596.656    -673.3523    -673.3523 
Loop time of 378.335 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.093 hours/ns, 2.643 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    | 377.26     | 377.26     | 377.26     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16166    | 0.16166    | 0.16166    |   0.0 |  0.04
Output  | 0.00027871 | 0.00027871 | 0.00027871 |   0.0 |  0.00
Modify  | 0.80499    | 0.80499    | 0.80499    |   0.0 |  0.21
Other   |            | 0.1065     |            |       |  0.03

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:      279848.0 ave      279848 max      279848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279848
Ave neighs/atom = 69.962000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.216780836529, Press = 0.620339786393502
next a
jump SELF top
variable a loop 2000
run 1000
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   -13082.133   -13082.133   -13259.764   -13259.764    343.63912    343.63912    67596.656    67596.656    -673.3523    -673.3523 
   23000   -13090.024   -13090.024   -13261.912   -13261.912      332.529      332.529    67488.716    67488.716    294.09892    294.09892 
Loop time of 384.063 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.684 hours/ns, 2.604 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    | 382.97     | 382.97     | 382.97     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16375    | 0.16375    | 0.16375    |   0.0 |  0.04
Output  | 0.00021263 | 0.00021263 | 0.00021263 |   0.0 |  0.00
Modify  | 0.82428    | 0.82428    | 0.82428    |   0.0 |  0.21
Other   |            | 0.1074     |            |       |  0.03

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:      279222.0 ave      279222 max      279222 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279222
Ave neighs/atom = 69.805500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.317669939594, Press = -0.399322483216235
next a
jump SELF top
variable a loop 2000
run 1000
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   -13090.024   -13090.024   -13261.912   -13261.912      332.529      332.529    67488.716    67488.716    294.09892    294.09892 
   24000   -13082.931   -13082.931   -13259.036   -13259.036    340.68654    340.68654     67593.17     67593.17    -590.0055    -590.0055 
Loop time of 384.613 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.837 hours/ns, 2.600 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    | 383.52     | 383.52     | 383.52     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16332    | 0.16332    | 0.16332    |   0.0 |  0.04
Output  | 0.00025072 | 0.00025072 | 0.00025072 |   0.0 |  0.00
Modify  | 0.82442    | 0.82442    | 0.82442    |   0.0 |  0.21
Other   |            | 0.1071     |            |       |  0.03

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:      280046.0 ave      280046 max      280046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280046
Ave neighs/atom = 70.011500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.484087523991, Press = 0.338286255621863
next a
jump SELF top
variable a loop 2000
run 1000
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   -13082.931   -13082.931   -13259.036   -13259.036    340.68654    340.68654     67593.17     67593.17    -590.0055    -590.0055 
   25000   -13088.723   -13088.723    -13260.31    -13260.31    331.94596    331.94596    67413.185    67413.185    1233.9326    1233.9326 
Loop time of 381.643 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.012 hours/ns, 2.620 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    | 380.56     | 380.56     | 380.56     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16208    | 0.16208    | 0.16208    |   0.0 |  0.04
Output  | 0.00018092 | 0.00018092 | 0.00018092 |   0.0 |  0.00
Modify  | 0.81899    | 0.81899    | 0.81899    |   0.0 |  0.21
Other   |            | 0.1058     |            |       |  0.03

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:      279274.0 ave      279274 max      279274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279274
Ave neighs/atom = 69.818500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.570260810803, Press = -0.505115975615763
next a
jump SELF top
variable a loop 2000
run 1000
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   -13088.723   -13088.723    -13260.31    -13260.31    331.94596    331.94596    67413.185    67413.185    1233.9326    1233.9326 
   26000   -13080.565   -13080.565   -13254.972   -13254.972     337.4008     337.4008    67661.674    67661.674   -1166.2185   -1166.2185 
Loop time of 386.351 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.320 hours/ns, 2.588 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    | 385.24     | 385.24     | 385.24     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16469    | 0.16469    | 0.16469    |   0.0 |  0.04
Output  | 0.00018309 | 0.00018309 | 0.00018309 |   0.0 |  0.00
Modify  | 0.83442    | 0.83442    | 0.83442    |   0.0 |  0.22
Other   |            | 0.1071     |            |       |  0.03

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:      280396.0 ave      280396 max      280396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280396
Ave neighs/atom = 70.099000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.636521892873, Press = 0.210013954335378
next a
jump SELF top
variable a loop 2000
run 1000
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   -13080.565   -13080.565   -13254.972   -13254.972     337.4008     337.4008    67661.674    67661.674   -1166.2185   -1166.2185 
   27000   -13088.626   -13088.626   -13258.695   -13258.695     329.0116     329.0116    67444.421    67444.421    1058.3602    1058.3602 
Loop time of 384.042 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.678 hours/ns, 2.604 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    | 382.94     | 382.94     | 382.94     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16504    | 0.16504    | 0.16504    |   0.0 |  0.04
Output  | 0.00018154 | 0.00018154 | 0.00018154 |   0.0 |  0.00
Modify  | 0.82702    | 0.82702    | 0.82702    |   0.0 |  0.22
Other   |            | 0.1064     |            |       |  0.03

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:      278316.0 ave      278316 max      278316 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278316
Ave neighs/atom = 69.579000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.743122233363, Press = 0.701454225830183
next a
jump SELF top
variable a loop 2000
run 1000
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   -13088.626   -13088.626   -13258.695   -13258.695     329.0116     329.0116    67444.421    67444.421    1058.3602    1058.3602 
   28000   -13083.343   -13083.343   -13257.571   -13257.571    337.05557    337.05557    67613.382    67613.382   -762.43643   -762.43643 
Loop time of 385.263 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.018 hours/ns, 2.596 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    | 384.17     | 384.17     | 384.17     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16371    | 0.16371    | 0.16371    |   0.0 |  0.04
Output  | 0.00018025 | 0.00018025 | 0.00018025 |   0.0 |  0.00
Modify  | 0.82632    | 0.82632    | 0.82632    |   0.0 |  0.21
Other   |            | 0.1063     |            |       |  0.03

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:      280588.0 ave      280588 max      280588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280588
Ave neighs/atom = 70.147000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.807702740821, Press = -1.32052272790332
next a
jump SELF top
variable a loop 2000
run 1000
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   -13083.343   -13083.343   -13257.571   -13257.571    337.05557    337.05557    67613.382    67613.382   -762.43643   -762.43643 
   29000   -13088.798   -13088.798   -13262.816   -13262.816    336.64961    336.64961    67494.147    67494.147    232.52475    232.52475 
Loop time of 386.181 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.272 hours/ns, 2.589 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    | 385.07     | 385.07     | 385.07     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1654     | 0.1654     | 0.1654     |   0.0 |  0.04
Output  | 0.00023737 | 0.00023737 | 0.00023737 |   0.0 |  0.00
Modify  | 0.83457    | 0.83457    | 0.83457    |   0.0 |  0.22
Other   |            | 0.1073     |            |       |  0.03

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:      278942.0 ave      278942 max      278942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278942
Ave neighs/atom = 69.735500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.761434319791, Press = 1.55781882656991
next a
jump SELF top
variable a loop 2000
run 1000
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.798   -13088.798   -13262.816   -13262.816    336.64961    336.64961    67494.147    67494.147    232.52475    232.52475 
   30000    -13089.34    -13089.34    -13260.85    -13260.85    331.79628    331.79628    67520.045    67520.045   -1.8987488   -1.8987488 
Loop time of 354.766 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.244 ns/day, 98.546 hours/ns, 2.819 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    | 353.77     | 353.77     | 353.77     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15182    | 0.15182    | 0.15182    |   0.0 |  0.04
Output  | 0.00022162 | 0.00022162 | 0.00022162 |   0.0 |  0.00
Modify  | 0.73819    | 0.73819    | 0.73819    |   0.0 |  0.21
Other   |            | 0.1017     |            |       |  0.03

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:      279928.0 ave      279928 max      279928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279928
Ave neighs/atom = 69.982000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.808687803593, Press = -1.23239634557342
next a
jump SELF top
variable a loop 2000
run 1000
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    -13089.34    -13089.34    -13260.85    -13260.85    331.79628    331.79628    67520.045    67520.045   -1.8987488   -1.8987488 
   31000   -13088.575   -13088.575   -13258.958   -13258.958    329.61702    329.61702    67547.775    67547.775   -123.16397   -123.16397 
Loop time of 355.022 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.243 ns/day, 98.617 hours/ns, 2.817 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    | 354.03     | 354.03     | 354.03     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15461    | 0.15461    | 0.15461    |   0.0 |  0.04
Output  | 0.00018304 | 0.00018304 | 0.00018304 |   0.0 |  0.00
Modify  | 0.73994    | 0.73994    | 0.73994    |   0.0 |  0.21
Other   |            | 0.09904    |            |       |  0.03

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:      279684.0 ave      279684 max      279684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279684
Ave neighs/atom = 69.921000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.831926360529, Press = 0.703924847058994
next a
jump SELF top
variable a loop 2000
run 1000
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   -13088.575   -13088.575   -13258.958   -13258.958    329.61702    329.61702    67547.775    67547.775   -123.16397   -123.16397 
   32000   -13084.293   -13084.293   -13259.377   -13259.377    338.71302    338.71302    67502.264    67502.264    395.50108    395.50108 
Loop time of 372.582 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.232 ns/day, 103.495 hours/ns, 2.684 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    | 371.53     | 371.53     | 371.53     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15653    | 0.15653    | 0.15653    |   0.0 |  0.04
Output  | 0.00018424 | 0.00018424 | 0.00018424 |   0.0 |  0.00
Modify  | 0.79222    | 0.79222    | 0.79222    |   0.0 |  0.21
Other   |            | 0.1032     |            |       |  0.03

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:      279678.0 ave      279678 max      279678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279678
Ave neighs/atom = 69.919500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.921233010289, Press = -0.59137448818497
next a
jump SELF top
variable a loop 2000
run 1000
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   -13084.293   -13084.293   -13259.377   -13259.377    338.71302    338.71302    67502.264    67502.264    395.50108    395.50108 
   33000   -13085.273   -13085.273   -13257.584   -13257.584    333.34736    333.34736    67620.782    67620.782   -841.76818   -841.76818 
Loop time of 350.587 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.246 ns/day, 97.385 hours/ns, 2.852 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    | 349.62     | 349.62     | 349.62     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14996    | 0.14996    | 0.14996    |   0.0 |  0.04
Output  | 0.00022685 | 0.00022685 | 0.00022685 |   0.0 |  0.00
Modify  | 0.72202    | 0.72202    | 0.72202    |   0.0 |  0.21
Other   |            | 0.09817    |            |       |  0.03

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:      279968.0 ave      279968 max      279968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279968
Ave neighs/atom = 69.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.964830333705, Press = 0.621644061960965
next a
jump SELF top
variable a loop 2000
run 1000
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   -13085.273   -13085.273   -13257.584   -13257.584    333.34736    333.34736    67620.782    67620.782   -841.76818   -841.76818 
   34000   -13091.565   -13091.565   -13262.122   -13262.122    329.95492    329.95492    67345.028    67345.028    1937.1428    1937.1428 
Loop time of 338.144 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.256 ns/day, 93.929 hours/ns, 2.957 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 337.21     | 337.21     | 337.21     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14539    | 0.14539    | 0.14539    |   0.0 |  0.04
Output  | 0.00017984 | 0.00017984 | 0.00017984 |   0.0 |  0.00
Modify  | 0.68792    | 0.68792    | 0.68792    |   0.0 |  0.20
Other   |            | 0.09594    |            |       |  0.03

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:      278766.0 ave      278766 max      278766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278766
Ave neighs/atom = 69.691500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.996423380275, Press = -0.388814389286775
next a
jump SELF top
variable a loop 2000
run 1000
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   -13091.565   -13091.565   -13262.122   -13262.122    329.95492    329.95492    67345.028    67345.028    1937.1428    1937.1428 
   35000   -13084.543   -13084.543   -13256.605   -13256.605    332.86486    332.86486    67641.817    67641.817   -1029.7948   -1029.7948 
Loop time of 353.866 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.244 ns/day, 98.296 hours/ns, 2.826 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    | 352.89     | 352.89     | 352.89     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15069    | 0.15069    | 0.15069    |   0.0 |  0.04
Output  | 0.00023288 | 0.00023288 | 0.00023288 |   0.0 |  0.00
Modify  | 0.73017    | 0.73017    | 0.73017    |   0.0 |  0.21
Other   |            | 0.09906    |            |       |  0.03

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:      281226.0 ave      281226 max      281226 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 281226
Ave neighs/atom = 70.306500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.928682794358, Press = -0.373250297718511
next a
jump SELF top
variable a loop 2000
run 1000
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   -13084.543   -13084.543   -13256.605   -13256.605    332.86486    332.86486    67641.817    67641.817   -1029.7948   -1029.7948 
   36000   -13093.116   -13093.116   -13262.222   -13262.222    327.14705    327.14705    67467.611    67467.611    493.84062    493.84062 
Loop time of 367.689 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.235 ns/day, 102.136 hours/ns, 2.720 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    | 366.66     | 366.66     | 366.66     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15541    | 0.15541    | 0.15541    |   0.0 |  0.04
Output  | 0.00027156 | 0.00027156 | 0.00027156 |   0.0 |  0.00
Modify  | 0.77404    | 0.77404    | 0.77404    |   0.0 |  0.21
Other   |            | 0.1035     |            |       |  0.03

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:      278586.0 ave      278586 max      278586 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 278586
Ave neighs/atom = 69.646500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.910875205626, Press = 0.431453300737081
next a
jump SELF top
variable a loop 2000
run 1000
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   -13093.116   -13093.116   -13262.222   -13262.222    327.14705    327.14705    67467.611    67467.611    493.84062    493.84062 
   37000   -13085.822   -13085.822   -13257.814   -13257.814    332.73074    332.73074    67561.098    67561.098   -205.45335   -205.45335 
Loop time of 375.668 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.352 hours/ns, 2.662 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    | 374.6      | 374.6      | 374.6      |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15982    | 0.15982    | 0.15982    |   0.0 |  0.04
Output  | 0.00017946 | 0.00017946 | 0.00017946 |   0.0 |  0.00
Modify  | 0.80388    | 0.80388    | 0.80388    |   0.0 |  0.21
Other   |            | 0.1061     |            |       |  0.03

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:      280272.0 ave      280272 max      280272 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 280272
Ave neighs/atom = 70.068000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.867992240755, Press = -0.528023019569738
next a
jump SELF top
variable a loop 2000
run 1000
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   -13085.822   -13085.822   -13257.814   -13257.814    332.73074    332.73074    67561.098    67561.098   -205.45335   -205.45335 
   38000   -13090.332   -13090.332   -13260.901   -13260.901    329.97904    329.97904    67515.083    67515.083    118.44666    118.44666 
Loop time of 349.955 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.247 ns/day, 97.210 hours/ns, 2.858 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    | 348.98     | 348.98     | 348.98     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15027    | 0.15027    | 0.15027    |   0.0 |  0.04
Output  | 0.00022126 | 0.00022126 | 0.00022126 |   0.0 |  0.00
Modify  | 0.72289    | 0.72289    | 0.72289    |   0.0 |  0.21
Other   |            | 0.09803    |            |       |  0.03

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:      279278.0 ave      279278 max      279278 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279278
Ave neighs/atom = 69.819500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.840537136557, Press = 0.717420765459983
next a
jump SELF top
variable a loop 2000
run 1000
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   -13090.332   -13090.332   -13260.901   -13260.901    329.97904    329.97904    67515.083    67515.083    118.44666    118.44666 
   39000   -13088.009   -13088.009   -13257.713   -13257.713    328.30448    328.30448    67532.366    67532.366     140.2784     140.2784 
Loop time of 343.056 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.252 ns/day, 95.293 hours/ns, 2.915 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    | 342.11     | 342.11     | 342.11     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14888    | 0.14888    | 0.14888    |   0.0 |  0.04
Output  | 0.00028042 | 0.00028042 | 0.00028042 |   0.0 |  0.00
Modify  | 0.70117    | 0.70117    | 0.70117    |   0.0 |  0.20
Other   |            | 0.09631    |            |       |  0.03

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:      279808.0 ave      279808 max      279808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279808
Ave neighs/atom = 69.952000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.879641823077, Press = -0.94816960459385
next a
jump SELF top
variable a loop 2000
run 1000
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   -13088.009   -13088.009   -13257.713   -13257.713    328.30448    328.30448    67532.366    67532.366     140.2784     140.2784 
   40000   -13081.412   -13081.412   -13256.616   -13256.616    338.94333    338.94333    67617.655    67617.655   -683.29075   -683.29075 
Loop time of 340.775 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.254 ns/day, 94.660 hours/ns, 2.934 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    | 339.83     | 339.83     | 339.83     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14732    | 0.14732    | 0.14732    |   0.0 |  0.04
Output  | 0.00018416 | 0.00018416 | 0.00018416 |   0.0 |  0.00
Modify  | 0.69622    | 0.69622    | 0.69622    |   0.0 |  0.20
Other   |            | 0.09704    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5836.00 ave        5836 max        5836 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      279740.0 ave      279740 max      279740 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279740
Ave neighs/atom = 69.935000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.907331609466, Press = 1.15675057384392
next a
jump SELF top
variable a loop 2000
run 1000
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   -13081.412   -13081.412   -13256.616   -13256.616    338.94333    338.94333    67617.655    67617.655   -683.29075   -683.29075 
   41000   -13087.416   -13087.416   -13258.526   -13258.526    331.02353    331.02353     67444.33     67444.33    1046.2411    1046.2411 
Loop time of 332.988 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.259 ns/day, 92.497 hours/ns, 3.003 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    | 332.08     | 332.08     | 332.08     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14384    | 0.14384    | 0.14384    |   0.0 |  0.04
Output  | 0.00047857 | 0.00047857 | 0.00047857 |   0.0 |  0.00
Modify  | 0.67032    | 0.67032    | 0.67032    |   0.0 |  0.20
Other   |            | 0.09398    |            |       |  0.03

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:      279032.0 ave      279032 max      279032 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279032
Ave neighs/atom = 69.758000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.912576942836, Press = -0.725093322244375
next a
jump SELF top
variable a loop 2000
run 1000
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   -13087.416   -13087.416   -13258.526   -13258.526    331.02353    331.02353     67444.33     67444.33    1046.2411    1046.2411 
   42000    -13090.41    -13090.41     -13263.2     -13263.2    334.27408    334.27408    67572.834    67572.834   -690.32313   -690.32313 
Loop time of 366.54 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.236 ns/day, 101.817 hours/ns, 2.728 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    | 365.47     | 365.47     | 365.47     |   0.0 | 99.71
Neigh   | 0.047218   | 0.047218   | 0.047218   |   0.0 |  0.01
Comm    | 0.16021    | 0.16021    | 0.16021    |   0.0 |  0.04
Output  | 0.00017902 | 0.00017902 | 0.00017902 |   0.0 |  0.00
Modify  | 0.76529    | 0.76529    | 0.76529    |   0.0 |  0.21
Other   |            | 0.1013     |            |       |  0.03

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 = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.93998981913, Press = 0.0113341522843428
next a
jump SELF top
variable a loop 2000
run 1000
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    -13090.41    -13090.41     -13263.2     -13263.2    334.27408    334.27408    67572.834    67572.834   -690.32313   -690.32313 
   43000   -13089.644   -13089.644   -13260.955   -13260.955    331.41385    331.41385    67489.394    67489.394    327.11488    327.11488 
Loop time of 338.42 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.255 ns/day, 94.006 hours/ns, 2.955 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    | 337.49     | 337.49     | 337.49     |   0.0 | 99.72
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1463     | 0.1463     | 0.1463     |   0.0 |  0.04
Output  | 0.00031152 | 0.00031152 | 0.00031152 |   0.0 |  0.00
Modify  | 0.69167    | 0.69167    | 0.69167    |   0.0 |  0.20
Other   |            | 0.09448    |            |       |  0.03

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:      279634.0 ave      279634 max      279634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 279634
Ave neighs/atom = 69.908500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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.7559136715

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0