# 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.044650822877884*${_u_distance}
variable latticeconst_converted equal 4.044650822877884*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  4.04465082287788
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_KimKimLee_2009_AlMg__MO_058537087384_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.2528701086    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66167.2528701086/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 66167.2528701086/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 66167.2528701086/(1*1*${_u_distance})
variable      V0_metal equal 66167.2528701086/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 66167.2528701086*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 66167.2528701086 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_058537087384_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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 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.253    66167.253    2779.8962    2779.8962 
    1000   -13075.359   -13075.359   -13255.181   -13255.181     347.8789     347.8789    67709.656    67709.656   -1536.5078   -1536.5078 
Loop time of 395.641 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 109.900 hours/ns, 2.528 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    | 394.71     | 394.71     | 394.71     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.149      | 0.149      | 0.149      |   0.0 |  0.04
Output  | 0.00027806 | 0.00027806 | 0.00027806 |   0.0 |  0.00
Modify  | 0.68872    | 0.68872    | 0.68872    |   0.0 |  0.17
Other   |            | 0.09585    |            |       |  0.02

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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -13075.359   -13075.359   -13255.181   -13255.181     347.8789     347.8789    67709.656    67709.656   -1536.5078   -1536.5078 
    2000   -13094.787   -13094.787   -13266.546   -13266.546    332.27822    332.27822    67471.611    67471.611    217.77104    217.77104 
Loop time of 428.404 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 119.001 hours/ns, 2.334 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    | 427.41     | 427.41     | 427.41     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15481    | 0.15481    | 0.15481    |   0.0 |  0.04
Output  | 0.00021576 | 0.00021576 | 0.00021576 |   0.0 |  0.00
Modify  | 0.73927    | 0.73927    | 0.73927    |   0.0 |  0.17
Other   |            | 0.09858    |            |       |  0.02

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:      322426.0 ave      322426 max      322426 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322426
Ave neighs/atom = 80.606500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -13094.787   -13094.787   -13266.546   -13266.546    332.27822    332.27822    67471.611    67471.611    217.77104    217.77104 
    3000   -13081.184   -13081.184    -13252.35    -13252.35    331.13171    331.13171    67555.778    67555.778    226.53217    226.53217 
Loop time of 453.073 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.191 ns/day, 125.854 hours/ns, 2.207 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    | 452.01     | 452.01     | 452.01     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16165    | 0.16165    | 0.16165    |   0.0 |  0.04
Output  | 0.000255   | 0.000255   | 0.000255   |   0.0 |  0.00
Modify  | 0.7994     | 0.7994     | 0.7994     |   0.0 |  0.18
Other   |            | 0.1034     |            |       |  0.02

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:      323082.0 ave      323082 max      323082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323082
Ave neighs/atom = 80.770500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -13081.184   -13081.184    -13252.35    -13252.35    331.13171    331.13171    67555.778    67555.778    226.53217    226.53217 
    4000   -13091.557   -13091.557   -13261.588   -13261.588     328.9354     328.9354    67536.578    67536.578   -235.07983   -235.07983 
Loop time of 426.143 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.373 hours/ns, 2.347 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 425.16     | 425.16     | 425.16     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15373    | 0.15373    | 0.15373    |   0.0 |  0.04
Output  | 0.00021964 | 0.00021964 | 0.00021964 |   0.0 |  0.00
Modify  | 0.72883    | 0.72883    | 0.72883    |   0.0 |  0.17
Other   |            | 0.09892    |            |       |  0.02

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:      323082.0 ave      323082 max      323082 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323082
Ave neighs/atom = 80.770500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -13091.557   -13091.557   -13261.588   -13261.588     328.9354     328.9354    67536.578    67536.578   -235.07983   -235.07983 
    5000   -13085.454   -13085.454   -13259.453   -13259.453    336.61235    336.61235    67526.099    67526.099    52.386878    52.386878 
Loop time of 428.208 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.947 hours/ns, 2.335 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    | 427.22     | 427.22     | 427.22     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15355    | 0.15355    | 0.15355    |   0.0 |  0.04
Output  | 0.00023691 | 0.00023691 | 0.00023691 |   0.0 |  0.00
Modify  | 0.73698    | 0.73698    | 0.73698    |   0.0 |  0.17
Other   |            | 0.1001     |            |       |  0.02

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:      322962.0 ave      322962 max      322962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322962
Ave neighs/atom = 80.740500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.060472169952, Press = -157.457238124431
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -13085.454   -13085.454   -13259.453   -13259.453    336.61235    336.61235    67526.099    67526.099    52.386878    52.386878 
    6000   -13087.075   -13087.075   -13259.941   -13259.941    334.42214    334.42214    67568.171    67568.171    -435.7594    -435.7594 
Loop time of 394.325 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.535 hours/ns, 2.536 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 393.42     | 393.42     | 393.42     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1397     | 0.1397     | 0.1397     |   0.0 |  0.04
Output  | 0.0001788  | 0.0001788  | 0.0001788  |   0.0 |  0.00
Modify  | 0.6696     | 0.6696     | 0.6696     |   0.0 |  0.17
Other   |            | 0.09544    |            |       |  0.02

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:      323048.0 ave      323048 max      323048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323048
Ave neighs/atom = 80.762000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.721317534723, Press = 15.014987834536
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -13087.075   -13087.075   -13259.941   -13259.941    334.42214    334.42214    67568.171    67568.171    -435.7594    -435.7594 
    7000   -13088.344   -13088.344   -13260.093   -13260.093    332.25964    332.25964     67444.71     67444.71    906.03212    906.03212 
Loop time of 393.736 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.371 hours/ns, 2.540 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 392.83     | 392.83     | 392.83     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14079    | 0.14079    | 0.14079    |   0.0 |  0.04
Output  | 0.00018052 | 0.00018052 | 0.00018052 |   0.0 |  0.00
Modify  | 0.66719    | 0.66719    | 0.66719    |   0.0 |  0.17
Other   |            | 0.0946     |            |       |  0.02

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:      322794.0 ave      322794 max      322794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322794
Ave neighs/atom = 80.698500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.207552201388, Press = -19.9539220933045
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -13088.344   -13088.344   -13260.093   -13260.093    332.25964    332.25964     67444.71     67444.71    906.03212    906.03212 
    8000    -13087.19    -13087.19   -13255.991   -13255.991    326.55662    326.55662     67668.77     67668.77   -1396.3823   -1396.3823 
Loop time of 437.331 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.198 ns/day, 121.481 hours/ns, 2.287 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    | 436.3      | 436.3      | 436.3      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15522    | 0.15522    | 0.15522    |   0.0 |  0.04
Output  | 0.0003108  | 0.0003108  | 0.0003108  |   0.0 |  0.00
Modify  | 0.77774    | 0.77774    | 0.77774    |   0.0 |  0.18
Other   |            | 0.1023     |            |       |  0.02

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:      323088.0 ave      323088 max      323088 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323088
Ave neighs/atom = 80.772000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.928826348947, Press = 6.32044947681683
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000    -13087.19    -13087.19   -13255.991   -13255.991    326.55662    326.55662     67668.77     67668.77   -1396.3823   -1396.3823 
    9000   -13091.307   -13091.307   -13260.989   -13260.989    328.26263    328.26263    67431.108    67431.108    935.11371    935.11371 
Loop time of 455.789 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.190 ns/day, 126.608 hours/ns, 2.194 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    | 454.69     | 454.69     | 454.69     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16201    | 0.16201    | 0.16201    |   0.0 |  0.04
Output  | 0.00017904 | 0.00017904 | 0.00017904 |   0.0 |  0.00
Modify  | 0.8306     | 0.8306     | 0.8306     |   0.0 |  0.18
Other   |            | 0.1054     |            |       |  0.02

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:      322718.0 ave      322718 max      322718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322718
Ave neighs/atom = 80.679500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.689062120914, Press = -1.15740381504691
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -13091.307   -13091.307   -13260.989   -13260.989    328.26263    328.26263    67431.108    67431.108    935.11371    935.11371 
   10000   -13087.459   -13087.459   -13260.117   -13260.117    334.01832    334.01832    67587.696    67587.696   -748.50425   -748.50425 
Loop time of 434.575 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.715 hours/ns, 2.301 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 433.54     | 433.54     | 433.54     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15642    | 0.15642    | 0.15642    |   0.0 |  0.04
Output  | 0.00022504 | 0.00022504 | 0.00022504 |   0.0 |  0.00
Modify  | 0.77844    | 0.77844    | 0.77844    |   0.0 |  0.18
Other   |            | 0.1012     |            |       |  0.02

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:      323128.0 ave      323128 max      323128 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323128
Ave neighs/atom = 80.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 = 332.38190716029, Press = -1.19309815624
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -13087.459   -13087.459   -13260.117   -13260.117    334.01832    334.01832    67587.696    67587.696   -748.50425   -748.50425 
   11000   -13088.606   -13088.606    -13259.46    -13259.46    330.52887    330.52887    67498.625    67498.625    393.51968    393.51968 
Loop time of 448.885 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 124.690 hours/ns, 2.228 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 447.8      | 447.8      | 447.8      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16112    | 0.16112    | 0.16112    |   0.0 |  0.04
Output  | 0.0002227  | 0.0002227  | 0.0002227  |   0.0 |  0.00
Modify  | 0.81869    | 0.81869    | 0.81869    |   0.0 |  0.18
Other   |            | 0.1039     |            |       |  0.02

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:      322806.0 ave      322806 max      322806 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322806
Ave neighs/atom = 80.701500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.542159584548, Press = 0.595335105941451
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -13088.606   -13088.606    -13259.46    -13259.46    330.52887    330.52887    67498.625    67498.625    393.51968    393.51968 
   12000   -13090.591   -13090.591   -13260.642   -13260.642    328.97483    328.97483    67566.932    67566.932   -490.42179   -490.42179 
Loop time of 439.005 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.197 ns/day, 121.946 hours/ns, 2.278 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 437.95     | 437.95     | 437.95     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15829    | 0.15829    | 0.15829    |   0.0 |  0.04
Output  | 0.00021642 | 0.00021642 | 0.00021642 |   0.0 |  0.00
Modify  | 0.79205    | 0.79205    | 0.79205    |   0.0 |  0.18
Other   |            | 0.1025     |            |       |  0.02

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:      323026.0 ave      323026 max      323026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323026
Ave neighs/atom = 80.756500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.287001721953, Press = -1.18108984232221
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -13090.591   -13090.591   -13260.642   -13260.642    328.97483    328.97483    67566.932    67566.932   -490.42179   -490.42179 
   13000   -13081.771   -13081.771   -13258.592   -13258.592     342.0705     342.0705     67463.06     67463.06    912.50298    912.50298 
Loop time of 452.805 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.191 ns/day, 125.779 hours/ns, 2.208 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    | 451.71     | 451.71     | 451.71     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16317    | 0.16317    | 0.16317    |   0.0 |  0.04
Output  | 0.00017854 | 0.00017854 | 0.00017854 |   0.0 |  0.00
Modify  | 0.83119    | 0.83119    | 0.83119    |   0.0 |  0.18
Other   |            | 0.1056     |            |       |  0.02

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:      322840.0 ave      322840 max      322840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322840
Ave neighs/atom = 80.710000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.3760230921, Press = 3.33059250176243
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -13081.771   -13081.771   -13258.592   -13258.592     342.0705     342.0705     67463.06     67463.06    912.50298    912.50298 
   14000   -13086.163   -13086.163   -13259.018   -13259.018    334.40001    334.40001    67609.293    67609.293   -827.96971   -827.96971 
Loop time of 453.906 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.190 ns/day, 126.085 hours/ns, 2.203 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    | 452.81     | 452.81     | 452.81     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1623     | 0.1623     | 0.1623     |   0.0 |  0.04
Output  | 0.00024894 | 0.00024894 | 0.00024894 |   0.0 |  0.00
Modify  | 0.82883    | 0.82883    | 0.82883    |   0.0 |  0.18
Other   |            | 0.1057     |            |       |  0.02

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:      323154.0 ave      323154 max      323154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323154
Ave neighs/atom = 80.788500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.480585668951, Press = -5.38883502983052
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -13086.163   -13086.163   -13259.018   -13259.018    334.40001    334.40001    67609.293    67609.293   -827.96971   -827.96971 
   15000   -13087.965   -13087.965   -13257.488   -13257.488    327.95339    327.95339    67532.641    67532.641    31.519948    31.519948 
Loop time of 450.141 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 125.039 hours/ns, 2.222 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    | 449.06     | 449.06     | 449.06     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16089    | 0.16089    | 0.16089    |   0.0 |  0.04
Output  | 0.00029141 | 0.00029141 | 0.00029141 |   0.0 |  0.00
Modify  | 0.81723    | 0.81723    | 0.81723    |   0.0 |  0.18
Other   |            | 0.1048     |            |       |  0.02

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:      322678.0 ave      322678 max      322678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322678
Ave neighs/atom = 80.669500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.692071537069, Press = 2.71048300416155
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -13087.965   -13087.965   -13257.488   -13257.488    327.95339    327.95339    67532.641    67532.641    31.519948    31.519948 
   16000   -13092.075   -13092.075   -13262.359   -13262.359     329.4262     329.4262    67459.717    67459.717    593.07758    593.07758 
Loop time of 458.028 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.189 ns/day, 127.230 hours/ns, 2.183 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 456.93     | 456.93     | 456.93     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16246    | 0.16246    | 0.16246    |   0.0 |  0.04
Output  | 0.00022977 | 0.00022977 | 0.00022977 |   0.0 |  0.00
Modify  | 0.83297    | 0.83297    | 0.83297    |   0.0 |  0.18
Other   |            | 0.1069     |            |       |  0.02

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:      323026.0 ave      323026 max      323026 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323026
Ave neighs/atom = 80.756500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.604433710702, Press = -1.11003731529289
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -13092.075   -13092.075   -13262.359   -13262.359     329.4262     329.4262    67459.717    67459.717    593.07758    593.07758 
   17000    -13085.18    -13085.18   -13256.581   -13256.581    331.58622    331.58622    67583.157    67583.157   -352.39644   -352.39644 
Loop time of 457.035 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.189 ns/day, 126.954 hours/ns, 2.188 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    | 455.93     | 455.93     | 455.93     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16255    | 0.16255    | 0.16255    |   0.0 |  0.04
Output  | 0.00022714 | 0.00022714 | 0.00022714 |   0.0 |  0.00
Modify  | 0.83554    | 0.83554    | 0.83554    |   0.0 |  0.18
Other   |            | 0.1056     |            |       |  0.02

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:      323248.0 ave      323248 max      323248 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323248
Ave neighs/atom = 80.812000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.567357203575, Press = -0.178135730500311
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000    -13085.18    -13085.18   -13256.581   -13256.581    331.58622    331.58622    67583.157    67583.157   -352.39644   -352.39644 
   18000   -13089.474   -13089.474   -13260.711   -13260.711    331.26978    331.26978    67435.754    67435.754    1031.3244    1031.3244 
Loop time of 450.228 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.192 ns/day, 125.063 hours/ns, 2.221 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    | 449.13     | 449.13     | 449.13     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16328    | 0.16328    | 0.16328    |   0.0 |  0.04
Output  | 0.00017936 | 0.00017936 | 0.00017936 |   0.0 |  0.00
Modify  | 0.82962    | 0.82962    | 0.82962    |   0.0 |  0.18
Other   |            | 0.1046     |            |       |  0.02

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:      322808.0 ave      322808 max      322808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322808
Ave neighs/atom = 80.702000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.455873474553, Press = 0.254401927194314
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -13089.474   -13089.474   -13260.711   -13260.711    331.26978    331.26978    67435.754    67435.754    1031.3244    1031.3244 
   19000    -13085.24    -13085.24   -13258.338   -13258.338    334.87023    334.87023    67677.131    67677.131   -1529.2063   -1529.2063 
Loop time of 455.428 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.190 ns/day, 126.508 hours/ns, 2.196 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    | 454.33     | 454.33     | 454.33     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16201    | 0.16201    | 0.16201    |   0.0 |  0.04
Output  | 0.00022651 | 0.00022651 | 0.00022651 |   0.0 |  0.00
Modify  | 0.82968    | 0.82968    | 0.82968    |   0.0 |  0.18
Other   |            | 0.1052     |            |       |  0.02

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:      323228.0 ave      323228 max      323228 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323228
Ave neighs/atom = 80.807000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.395044219265, Press = -2.13670997030263
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000    -13085.24    -13085.24   -13258.338   -13258.338    334.87023    334.87023    67677.131    67677.131   -1529.2063   -1529.2063 
   20000   -13089.644   -13089.644   -13259.707   -13259.707    328.99771    328.99771    67442.932    67442.932    946.30512    946.30512 
Loop time of 453.523 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.191 ns/day, 125.979 hours/ns, 2.205 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    | 452.42     | 452.42     | 452.42     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16278    | 0.16278    | 0.16278    |   0.0 |  0.04
Output  | 0.00023484 | 0.00023484 | 0.00023484 |   0.0 |  0.00
Modify  | 0.8332     | 0.8332     | 0.8332     |   0.0 |  0.18
Other   |            | 0.1049     |            |       |  0.02

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:      322508.0 ave      322508 max      322508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322508
Ave neighs/atom = 80.627000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.319197194773, Press = 2.14506965402675
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -13089.644   -13089.644   -13259.707   -13259.707    328.99771    328.99771    67442.932    67442.932    946.30512    946.30512 
   21000   -13090.256   -13090.256   -13261.289   -13261.289    330.87374    330.87374    67532.925    67532.925   -186.78824   -186.78824 
Loop time of 454.849 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.190 ns/day, 126.347 hours/ns, 2.199 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    | 453.74     | 453.74     | 453.74     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16253    | 0.16253    | 0.16253    |   0.0 |  0.04
Output  | 0.00017816 | 0.00017816 | 0.00017816 |   0.0 |  0.00
Modify  | 0.83961    | 0.83961    | 0.83961    |   0.0 |  0.18
Other   |            | 0.1062     |            |       |  0.02

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:      323216.0 ave      323216 max      323216 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323216
Ave neighs/atom = 80.804000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.35590832772, Press = -1.65684924409675
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -13090.256   -13090.256   -13261.289   -13261.289    330.87374    330.87374    67532.925    67532.925   -186.78824   -186.78824 
   22000   -13081.621   -13081.621   -13253.868   -13253.868    333.22337    333.22337    67562.333    67562.333    -8.640418    -8.640418 
Loop time of 457.218 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.189 ns/day, 127.005 hours/ns, 2.187 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 456.11     | 456.11     | 456.11     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16213    | 0.16213    | 0.16213    |   0.0 |  0.04
Output  | 0.00017849 | 0.00017849 | 0.00017849 |   0.0 |  0.00
Modify  | 0.83711    | 0.83711    | 0.83711    |   0.0 |  0.18
Other   |            | 0.1058     |            |       |  0.02

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:      323050.0 ave      323050 max      323050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323050
Ave neighs/atom = 80.762500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.494236117443, Press = 0.0996916278464093
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -13081.621   -13081.621   -13253.868   -13253.868    333.22337    333.22337    67562.333    67562.333    -8.640418    -8.640418 
   23000   -13087.998   -13087.998    -13260.81    -13260.81    334.31678    334.31678    67505.576    67505.576    192.06043    192.06043 
Loop time of 447.712 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.193 ns/day, 124.364 hours/ns, 2.234 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    | 446.63     | 446.63     | 446.63     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15959    | 0.15959    | 0.15959    |   0.0 |  0.04
Output  | 0.0001768  | 0.0001768  | 0.0001768  |   0.0 |  0.00
Modify  | 0.82029    | 0.82029    | 0.82029    |   0.0 |  0.18
Other   |            | 0.105      |            |       |  0.02

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:      323004.0 ave      323004 max      323004 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323004
Ave neighs/atom = 80.751000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.602082671942, Press = -0.631443117282239
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -13087.998   -13087.998    -13260.81    -13260.81    334.31678    334.31678    67505.576    67505.576    192.06043    192.06043 
   24000   -13085.116   -13085.116   -13257.978   -13257.978    334.41206    334.41206     67586.54     67586.54   -459.92106   -459.92106 
Loop time of 417.68 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 116.022 hours/ns, 2.394 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    | 416.69     | 416.69     | 416.69     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14946    | 0.14946    | 0.14946    |   0.0 |  0.04
Output  | 0.00029973 | 0.00029973 | 0.00029973 |   0.0 |  0.00
Modify  | 0.74073    | 0.74073    | 0.74073    |   0.0 |  0.18
Other   |            | 0.09978    |            |       |  0.02

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:      323100.0 ave      323100 max      323100 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323100
Ave neighs/atom = 80.775000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.633120055575, Press = 0.484145401944043
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -13085.116   -13085.116   -13257.978   -13257.978    334.41206    334.41206     67586.54     67586.54   -459.92106   -459.92106 
   25000   -13089.601   -13089.601   -13260.266   -13260.266    330.16392    330.16392    67446.312    67446.312    891.29986    891.29986 
Loop time of 459.17 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.188 ns/day, 127.547 hours/ns, 2.178 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    | 458.07     | 458.07     | 458.07     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16153    | 0.16153    | 0.16153    |   0.0 |  0.04
Output  | 0.00023018 | 0.00023018 | 0.00023018 |   0.0 |  0.00
Modify  | 0.83626    | 0.83626    | 0.83626    |   0.0 |  0.18
Other   |            | 0.1053     |            |       |  0.02

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:      322824.0 ave      322824 max      322824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322824
Ave neighs/atom = 80.706000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.612411508111, Press = -1.10841088309425
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -13089.601   -13089.601   -13260.266   -13260.266    330.16392    330.16392    67446.312    67446.312    891.29986    891.29986 
   26000   -13087.672   -13087.672   -13258.064   -13258.064    329.63448    329.63448    67648.541    67648.541    -1187.578    -1187.578 
Loop time of 454.955 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.190 ns/day, 126.376 hours/ns, 2.198 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    | 453.86     | 453.86     | 453.86     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16051    | 0.16051    | 0.16051    |   0.0 |  0.04
Output  | 0.00022916 | 0.00022916 | 0.00022916 |   0.0 |  0.00
Modify  | 0.8248     | 0.8248     | 0.8248     |   0.0 |  0.18
Other   |            | 0.1045     |            |       |  0.02

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:      323210.0 ave      323210 max      323210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323210
Ave neighs/atom = 80.802500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.629304118675, Press = 0.0867755061209655
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -13087.672   -13087.672   -13258.064   -13258.064    329.63448    329.63448    67648.541    67648.541    -1187.578    -1187.578 
   27000   -13089.901   -13089.901   -13262.263   -13262.263    333.44506    333.44506    67405.561    67405.561    1227.0309    1227.0309 
Loop time of 444.343 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.194 ns/day, 123.429 hours/ns, 2.251 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    | 443.28     | 443.28     | 443.28     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15634    | 0.15634    | 0.15634    |   0.0 |  0.04
Output  | 0.00022113 | 0.00022113 | 0.00022113 |   0.0 |  0.00
Modify  | 0.80136    | 0.80136    | 0.80136    |   0.0 |  0.18
Other   |            | 0.1035     |            |       |  0.02

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:      322608.0 ave      322608 max      322608 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322608
Ave neighs/atom = 80.652000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.531601304268, Press = 0.37669032038566
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -13089.901   -13089.901   -13262.263   -13262.263    333.44506    333.44506    67405.561    67405.561    1227.0309    1227.0309 
   28000   -13088.961   -13088.961   -13260.224   -13260.224    331.31915    331.31915    67584.002    67584.002   -695.15783   -695.15783 
Loop time of 458.332 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.189 ns/day, 127.314 hours/ns, 2.182 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 457.24     | 457.24     | 457.24     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16134    | 0.16134    | 0.16134    |   0.0 |  0.04
Output  | 0.00022945 | 0.00022945 | 0.00022945 |   0.0 |  0.00
Modify  | 0.82624    | 0.82624    | 0.82624    |   0.0 |  0.18
Other   |            | 0.1048     |            |       |  0.02

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:      323366.0 ave      323366 max      323366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323366
Ave neighs/atom = 80.841500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.516751255688, Press = -0.744554591136231
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -13088.961   -13088.961   -13260.224   -13260.224    331.31915    331.31915    67584.002    67584.002   -695.15783   -695.15783 
   29000   -13089.106   -13089.106   -13260.973   -13260.973    332.48774    332.48774    67501.023    67501.023    191.86997    191.86997 
Loop time of 402.481 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.215 ns/day, 111.800 hours/ns, 2.485 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    | 401.54     | 401.54     | 401.54     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14492    | 0.14492    | 0.14492    |   0.0 |  0.04
Output  | 0.00017922 | 0.00017922 | 0.00017922 |   0.0 |  0.00
Modify  | 0.69758    | 0.69758    | 0.69758    |   0.0 |  0.17
Other   |            | 0.0957     |            |       |  0.02

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:      322790.0 ave      322790 max      322790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322790
Ave neighs/atom = 80.697500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.45346198646, Press = 0.344193304339755
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -13089.106   -13089.106   -13260.973   -13260.973    332.48774    332.48774    67501.023    67501.023    191.86997    191.86997 
   30000   -13088.374   -13088.374   -13257.788   -13257.788    327.74243    327.74243    67524.715    67524.715    139.83537    139.83537 
Loop time of 411.904 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.210 ns/day, 114.418 hours/ns, 2.428 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    | 410.94     | 410.94     | 410.94     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14673    | 0.14673    | 0.14673    |   0.0 |  0.04
Output  | 0.0001774  | 0.0001774  | 0.0001774  |   0.0 |  0.00
Modify  | 0.71543    | 0.71543    | 0.71543    |   0.0 |  0.17
Other   |            | 0.09866    |            |       |  0.02

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:      322924.0 ave      322924 max      322924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322924
Ave neighs/atom = 80.731000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.470942107248, Press = -0.538528111675243
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -13088.374   -13088.374   -13257.788   -13257.788    327.74243    327.74243    67524.715    67524.715    139.83537    139.83537 
   31000   -13084.167   -13084.167   -13256.511   -13256.511    333.41035    333.41035    67561.306    67561.306   -126.35663   -126.35663 
Loop time of 403.053 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.214 ns/day, 111.959 hours/ns, 2.481 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    | 402.12     | 402.12     | 402.12     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14542    | 0.14542    | 0.14542    |   0.0 |  0.04
Output  | 0.00022518 | 0.00022518 | 0.00022518 |   0.0 |  0.00
Modify  | 0.69341    | 0.69341    | 0.69341    |   0.0 |  0.17
Other   |            | 0.09595    |            |       |  0.02

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:      323012.0 ave      323012 max      323012 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323012
Ave neighs/atom = 80.753000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.415006701577, Press = 0.863356936480794
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -13084.167   -13084.167   -13256.511   -13256.511    333.41035    333.41035    67561.306    67561.306   -126.35663   -126.35663 
   32000   -13088.589   -13088.589   -13261.579   -13261.579    334.66199    334.66199    67446.107    67446.107    826.00136    826.00136 
Loop time of 451.621 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.191 ns/day, 125.450 hours/ns, 2.214 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    | 450.52     | 450.52     | 450.52     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16018    | 0.16018    | 0.16018    |   0.0 |  0.04
Output  | 0.00017847 | 0.00017847 | 0.00017847 |   0.0 |  0.00
Modify  | 0.83571    | 0.83571    | 0.83571    |   0.0 |  0.19
Other   |            | 0.1046     |            |       |  0.02

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:      322874.0 ave      322874 max      322874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322874
Ave neighs/atom = 80.718500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.460226046826, Press = -1.36856913192992
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -13088.589   -13088.589   -13261.579   -13261.579    334.66199    334.66199    67446.107    67446.107    826.00136    826.00136 
   33000    -13085.13    -13085.13   -13255.802   -13255.802    330.17643    330.17643    67632.264    67632.264   -857.63683   -857.63683 
Loop time of 402.444 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.215 ns/day, 111.790 hours/ns, 2.485 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 401.5      | 401.5      | 401.5      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14648    | 0.14648    | 0.14648    |   0.0 |  0.04
Output  | 0.00023328 | 0.00023328 | 0.00023328 |   0.0 |  0.00
Modify  | 0.69718    | 0.69718    | 0.69718    |   0.0 |  0.17
Other   |            | 0.09615    |            |       |  0.02

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:      323220.0 ave      323220 max      323220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323220
Ave neighs/atom = 80.805000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.563403232661, Press = 0.0362302382809514
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000    -13085.13    -13085.13   -13255.802   -13255.802    330.17643    330.17643    67632.264    67632.264   -857.63683   -857.63683 
   34000   -13086.727   -13086.727   -13260.137   -13260.137    335.47407    335.47407     67460.49     67460.49     832.8888     832.8888 
Loop time of 418.218 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 116.172 hours/ns, 2.391 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    | 417.24     | 417.24     | 417.24     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14979    | 0.14979    | 0.14979    |   0.0 |  0.04
Output  | 0.00021028 | 0.00021028 | 0.00021028 |   0.0 |  0.00
Modify  | 0.72675    | 0.72675    | 0.72675    |   0.0 |  0.17
Other   |            | 0.09942    |            |       |  0.02

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:      322774.0 ave      322774 max      322774 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322774
Ave neighs/atom = 80.693500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.620739341372, Press = 0.0844893933840628
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -13086.727   -13086.727   -13260.137   -13260.137    335.47407    335.47407     67460.49     67460.49     832.8888     832.8888 
   35000   -13089.254   -13089.254   -13261.948   -13261.948     334.0871     334.0871    67584.939    67584.939   -797.84415   -797.84415 
Loop time of 402.044 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.215 ns/day, 111.679 hours/ns, 2.487 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    | 401.11     | 401.11     | 401.11     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14282    | 0.14282    | 0.14282    |   0.0 |  0.04
Output  | 0.00017461 | 0.00017461 | 0.00017461 |   0.0 |  0.00
Modify  | 0.69197    | 0.69197    | 0.69197    |   0.0 |  0.17
Other   |            | 0.09765    |            |       |  0.02

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:      323282.0 ave      323282 max      323282 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323282
Ave neighs/atom = 80.820500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.702615417555, Press = -0.858990933967377
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -13089.254   -13089.254   -13261.948   -13261.948     334.0871     334.0871    67584.939    67584.939   -797.84415   -797.84415 
   36000   -13088.407   -13088.407   -13258.523   -13258.523    329.10035    329.10035    67482.483    67482.483    610.73331    610.73331 
Loop time of 429.939 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.427 hours/ns, 2.326 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 428.87     | 428.87     | 428.87     |   0.0 | 99.75
Neigh   | 0.052974   | 0.052974   | 0.052974   |   0.0 |  0.01
Comm    | 0.15757    | 0.15757    | 0.15757    |   0.0 |  0.04
Output  | 0.00017844 | 0.00017844 | 0.00017844 |   0.0 |  0.00
Modify  | 0.75812    | 0.75812    | 0.75812    |   0.0 |  0.18
Other   |            | 0.1006     |            |       |  0.02

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:      323210.0 ave      323210 max      323210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323210
Ave neighs/atom = 80.802500
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.722426336841, Press = 1.63024319319945
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -13088.407   -13088.407   -13258.523   -13258.523    329.10035    329.10035    67482.483    67482.483    610.73331    610.73331 
   37000   -13086.969   -13086.969   -13259.545   -13259.545    333.86059    333.86059    67524.796    67524.796    34.911361    34.911361 
Loop time of 394.309 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.530 hours/ns, 2.536 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    | 393.4      | 393.4      | 393.4      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14122    | 0.14122    | 0.14122    |   0.0 |  0.04
Output  | 0.00017606 | 0.00017606 | 0.00017606 |   0.0 |  0.00
Modify  | 0.67296    | 0.67296    | 0.67296    |   0.0 |  0.17
Other   |            | 0.09652    |            |       |  0.02

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:      323124.0 ave      323124 max      323124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323124
Ave neighs/atom = 80.781000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.727323362723, Press = -1.65830197300272
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -13086.969   -13086.969   -13259.545   -13259.545    333.86059    333.86059    67524.796    67524.796    34.911361    34.911361 
   38000   -13090.221   -13090.221   -13261.332   -13261.332    331.02514    331.02514    67537.138    67537.138   -146.32557   -146.32557 
Loop time of 393.59 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.330 hours/ns, 2.541 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    | 392.68     | 392.68     | 392.68     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1408     | 0.1408     | 0.1408     |   0.0 |  0.04
Output  | 0.00017798 | 0.00017798 | 0.00017798 |   0.0 |  0.00
Modify  | 0.6724     | 0.6724     | 0.6724     |   0.0 |  0.17
Other   |            | 0.09559    |            |       |  0.02

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:      323052.0 ave      323052 max      323052 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323052
Ave neighs/atom = 80.763000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.702332332461, Press = 0.608189891179857
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -13090.221   -13090.221   -13261.332   -13261.332    331.02514    331.02514    67537.138    67537.138   -146.32557   -146.32557 
   39000   -13082.944   -13082.944   -13259.779   -13259.779    342.09822    342.09822    67539.228    67539.228   -10.899478   -10.899478 
Loop time of 392.765 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.101 hours/ns, 2.546 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    | 391.85     | 391.85     | 391.85     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14172    | 0.14172    | 0.14172    |   0.0 |  0.04
Output  | 0.00017976 | 0.00017976 | 0.00017976 |   0.0 |  0.00
Modify  | 0.67293    | 0.67293    | 0.67293    |   0.0 |  0.17
Other   |            | 0.0961     |            |       |  0.02

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:      322870.0 ave      322870 max      322870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322870
Ave neighs/atom = 80.717500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.734503947682, Press = -0.677654248491373
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -13082.944   -13082.944   -13259.779   -13259.779    342.09822    342.09822    67539.228    67539.228   -10.899478   -10.899478 
   40000   -13089.781   -13089.781   -13259.978   -13259.978    329.25601    329.25601    67541.458    67541.458   -180.82444   -180.82444 
Loop time of 394.177 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.494 hours/ns, 2.537 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 393.27     | 393.27     | 393.27     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14055    | 0.14055    | 0.14055    |   0.0 |  0.04
Output  | 0.00017733 | 0.00017733 | 0.00017733 |   0.0 |  0.00
Modify  | 0.67184    | 0.67184    | 0.67184    |   0.0 |  0.17
Other   |            | 0.09716    |            |       |  0.02

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:      322932.0 ave      322932 max      322932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322932
Ave neighs/atom = 80.733000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.793354863314, Press = 0.261652196571917
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -13089.781   -13089.781   -13259.978   -13259.978    329.25601    329.25601    67541.458    67541.458   -180.82444   -180.82444 
   41000   -13091.247   -13091.247   -13264.482   -13264.482    335.13412    335.13412     67449.12     67449.12    618.81425    618.81425 
Loop time of 393.849 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.402 hours/ns, 2.539 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    | 392.94     | 392.94     | 392.94     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14048    | 0.14048    | 0.14048    |   0.0 |  0.04
Output  | 0.00025003 | 0.00025003 | 0.00025003 |   0.0 |  0.00
Modify  | 0.67403    | 0.67403    | 0.67403    |   0.0 |  0.17
Other   |            | 0.0958     |            |       |  0.02

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:      323048.0 ave      323048 max      323048 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323048
Ave neighs/atom = 80.762000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.819889701489, Press = -0.359397248322982
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -13091.247   -13091.247   -13264.482   -13264.482    335.13412    335.13412     67449.12     67449.12    618.81425    618.81425 
   42000   -13086.766   -13086.766   -13257.004   -13257.004    329.33744    329.33744    67658.349    67658.349   -1320.5703   -1320.5703 
Loop time of 392.925 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.146 hours/ns, 2.545 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    | 392.02     | 392.02     | 392.02     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14032    | 0.14032    | 0.14032    |   0.0 |  0.04
Output  | 0.00017912 | 0.00017912 | 0.00017912 |   0.0 |  0.00
Modify  | 0.66672    | 0.66672    | 0.66672    |   0.0 |  0.17
Other   |            | 0.0966     |            |       |  0.02

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:      323142.0 ave      323142 max      323142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323142
Ave neighs/atom = 80.785500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.770109212047, Press = 0.0243376675369605
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -13086.766   -13086.766   -13257.004   -13257.004    329.33744    329.33744    67658.349    67658.349   -1320.5703   -1320.5703 
   43000   -13092.723   -13092.723   -13261.806   -13261.806    327.10326    327.10326     67403.08     67403.08    1207.0617    1207.0617 
Loop time of 392.62 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.061 hours/ns, 2.547 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 391.72     | 391.72     | 391.72     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13933    | 0.13933    | 0.13933    |   0.0 |  0.04
Output  | 0.00017717 | 0.00017717 | 0.00017717 |   0.0 |  0.00
Modify  | 0.66666    | 0.66666    | 0.66666    |   0.0 |  0.17
Other   |            | 0.09627    |            |       |  0.02

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:      322610.0 ave      322610 max      322610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322610
Ave neighs/atom = 80.652500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.769802516015, Press = 0.177499139191519
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -13092.723   -13092.723   -13261.806   -13261.806    327.10326    327.10326     67403.08     67403.08    1207.0617    1207.0617 
   44000   -13084.712   -13084.712   -13257.228   -13257.228    333.74361    333.74361    67603.445    67603.445   -700.37074   -700.37074 
Loop time of 393.4 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.278 hours/ns, 2.542 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    | 392.49     | 392.49     | 392.49     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14092    | 0.14092    | 0.14092    |   0.0 |  0.04
Output  | 0.0001779  | 0.0001779  | 0.0001779  |   0.0 |  0.00
Modify  | 0.67257    | 0.67257    | 0.67257    |   0.0 |  0.17
Other   |            | 0.09565    |            |       |  0.02

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:      323252.0 ave      323252 max      323252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323252
Ave neighs/atom = 80.813000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.720412053089, Press = -0.685059193793764
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -13084.712   -13084.712   -13257.228   -13257.228    333.74361    333.74361    67603.445    67603.445   -700.37074   -700.37074 
   45000   -13089.601   -13089.601   -13260.362   -13260.362    330.34771    330.34771    67502.492    67502.492    249.33437    249.33437 
Loop time of 396.754 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 110.209 hours/ns, 2.520 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    | 395.83     | 395.83     | 395.83     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14208    | 0.14208    | 0.14208    |   0.0 |  0.04
Output  | 0.00018025 | 0.00018025 | 0.00018025 |   0.0 |  0.00
Modify  | 0.68101    | 0.68101    | 0.68101    |   0.0 |  0.17
Other   |            | 0.09632    |            |       |  0.02

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:      322686.0 ave      322686 max      322686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322686
Ave neighs/atom = 80.671500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.710201743779, Press = 0.444703518884428
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -13089.601   -13089.601   -13260.362   -13260.362    330.34771    330.34771    67502.492    67502.492    249.33437    249.33437 
   46000   -13080.659   -13080.659   -13256.952   -13256.952    341.05159    341.05159    67536.749    67536.749    182.17183    182.17183 
Loop time of 427.896 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.860 hours/ns, 2.337 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    | 426.89     | 426.89     | 426.89     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15334    | 0.15334    | 0.15334    |   0.0 |  0.04
Output  | 0.00021826 | 0.00021826 | 0.00021826 |   0.0 |  0.00
Modify  | 0.75226    | 0.75226    | 0.75226    |   0.0 |  0.18
Other   |            | 0.1013     |            |       |  0.02

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:      323062.0 ave      323062 max      323062 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323062
Ave neighs/atom = 80.765500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.746587943353, Press = -0.366928930398113
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -13080.659   -13080.659   -13256.952   -13256.952    341.05159    341.05159    67536.749    67536.749    182.17183    182.17183 
   47000   -13088.147   -13088.147   -13259.999   -13259.999    332.45868    332.45868    67585.619    67585.619   -724.43191   -724.43191 
Loop time of 395.017 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.727 hours/ns, 2.532 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    | 394.11     | 394.11     | 394.11     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13962    | 0.13962    | 0.13962    |   0.0 |  0.04
Output  | 0.0001773  | 0.0001773  | 0.0001773  |   0.0 |  0.00
Modify  | 0.67344    | 0.67344    | 0.67344    |   0.0 |  0.17
Other   |            | 0.09594    |            |       |  0.02

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:      322928.0 ave      322928 max      322928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322928
Ave neighs/atom = 80.732000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.782792377814, Press = 0.140336776824105
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -13088.147   -13088.147   -13259.999   -13259.999    332.45868    332.45868    67585.619    67585.619   -724.43191   -724.43191 
   48000    -13085.69    -13085.69   -13256.731   -13256.731    330.88998    330.88998     67409.18     67409.18    1606.2983    1606.2983 
Loop time of 413.34 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 114.817 hours/ns, 2.419 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    | 412.37     | 412.37     | 412.37     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14768    | 0.14768    | 0.14768    |   0.0 |  0.04
Output  | 0.00017655 | 0.00017655 | 0.00017655 |   0.0 |  0.00
Modify  | 0.72268    | 0.72268    | 0.72268    |   0.0 |  0.17
Other   |            | 0.09874    |            |       |  0.02

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:      322794.0 ave      322794 max      322794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322794
Ave neighs/atom = 80.698500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.776586874673, Press = -0.393474372044366
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000    -13085.69    -13085.69   -13256.731   -13256.731    330.88998    330.88998     67409.18     67409.18    1606.2983    1606.2983 
   49000   -13093.904   -13093.904   -13262.184   -13262.184    325.54772    325.54772    67654.828    67654.828   -1582.2971   -1582.2971 
Loop time of 393.271 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.242 hours/ns, 2.543 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    | 392.36     | 392.36     | 392.36     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1405     | 0.1405     | 0.1405     |   0.0 |  0.04
Output  | 0.00017678 | 0.00017678 | 0.00017678 |   0.0 |  0.00
Modify  | 0.67027    | 0.67027    | 0.67027    |   0.0 |  0.17
Other   |            | 0.09579    |            |       |  0.02

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:      323314.0 ave      323314 max      323314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323314
Ave neighs/atom = 80.828500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.777604385861, Press = -0.214829474199124
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -13093.904   -13093.904   -13262.184   -13262.184    325.54772    325.54772    67654.828    67654.828   -1582.2971   -1582.2971 
   50000   -13087.577   -13087.577    -13258.48    -13258.48    330.62508    330.62508    67442.759    67442.759    1024.4303    1024.4303 
Loop time of 392.254 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 108.959 hours/ns, 2.549 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    | 391.34     | 391.34     | 391.34     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14221    | 0.14221    | 0.14221    |   0.0 |  0.04
Output  | 0.00017738 | 0.00017738 | 0.00017738 |   0.0 |  0.00
Modify  | 0.67167    | 0.67167    | 0.67167    |   0.0 |  0.17
Other   |            | 0.09494    |            |       |  0.02

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:      322592.0 ave      322592 max      322592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322592
Ave neighs/atom = 80.648000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.73204715619, Press = 0.286061490959661
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -13087.577   -13087.577    -13258.48    -13258.48    330.62508    330.62508    67442.759    67442.759    1024.4303    1024.4303 
   51000   -13091.356   -13091.356   -13260.312   -13260.312    326.85772    326.85772    67538.238    67538.238   -222.94938   -222.94938 
Loop time of 423.321 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.589 hours/ns, 2.362 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    | 422.32     | 422.32     | 422.32     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15027    | 0.15027    | 0.15027    |   0.0 |  0.04
Output  | 0.00017902 | 0.00017902 | 0.00017902 |   0.0 |  0.00
Modify  | 0.74753    | 0.74753    | 0.74753    |   0.0 |  0.18
Other   |            | 0.09992    |            |       |  0.02

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:      323342.0 ave      323342 max      323342 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323342
Ave neighs/atom = 80.835500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.719850248661, Press = -0.283466181183472
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -13091.356   -13091.356   -13260.312   -13260.312    326.85772    326.85772    67538.238    67538.238   -222.94938   -222.94938 
   52000   -13084.793   -13084.793   -13254.619   -13254.619    328.54068    328.54068    67554.614    67554.614    98.788659    98.788659 
Loop time of 400.231 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 111.175 hours/ns, 2.499 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    | 399.3      | 399.3      | 399.3      |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14442    | 0.14442    | 0.14442    |   0.0 |  0.04
Output  | 0.00017835 | 0.00017835 | 0.00017835 |   0.0 |  0.00
Modify  | 0.68769    | 0.68769    | 0.68769    |   0.0 |  0.17
Other   |            | 0.09549    |            |       |  0.02

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:      322908.0 ave      322908 max      322908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322908
Ave neighs/atom = 80.727000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.696083618266, Press = -0.00665594251380929
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -13084.793   -13084.793   -13254.619   -13254.619    328.54068    328.54068    67554.614    67554.614    98.788659    98.788659 
   53000   -13086.941   -13086.941   -13257.923   -13257.923    330.77649    330.77649    67540.776    67540.776   -6.7759066   -6.7759066 
Loop time of 426.918 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.588 hours/ns, 2.342 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    | 425.91     | 425.91     | 425.91     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15435    | 0.15435    | 0.15435    |   0.0 |  0.04
Output  | 0.0001754  | 0.0001754  | 0.0001754  |   0.0 |  0.00
Modify  | 0.75635    | 0.75635    | 0.75635    |   0.0 |  0.18
Other   |            | 0.1015     |            |       |  0.02

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:      323002.0 ave      323002 max      323002 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323002
Ave neighs/atom = 80.750500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.713944698875, Press = -0.0612679090144958
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -13086.941   -13086.941   -13257.923   -13257.923    330.77649    330.77649    67540.776    67540.776   -6.7759066   -6.7759066 
   54000   -13084.443   -13084.443   -13258.924   -13258.924    337.54458    337.54458     67514.06     67514.06    270.82962    270.82962 
Loop time of 397.484 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.217 ns/day, 110.412 hours/ns, 2.516 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    | 396.57     | 396.57     | 396.57     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14118    | 0.14118    | 0.14118    |   0.0 |  0.04
Output  | 0.0001776  | 0.0001776  | 0.0001776  |   0.0 |  0.00
Modify  | 0.68165    | 0.68165    | 0.68165    |   0.0 |  0.17
Other   |            | 0.09588    |            |       |  0.02

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:      322990.0 ave      322990 max      322990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322990
Ave neighs/atom = 80.747500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.770154707646, Press = -0.216935815955366
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -13084.443   -13084.443   -13258.924   -13258.924    337.54458    337.54458     67514.06     67514.06    270.82962    270.82962 
   55000   -13084.449   -13084.449   -13258.598   -13258.598    336.90262    336.90262    67590.286    67590.286   -545.24873   -545.24873 
Loop time of 399.849 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.216 ns/day, 111.069 hours/ns, 2.501 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    | 398.92     | 398.92     | 398.92     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14227    | 0.14227    | 0.14227    |   0.0 |  0.04
Output  | 0.00017884 | 0.00017884 | 0.00017884 |   0.0 |  0.00
Modify  | 0.68866    | 0.68866    | 0.68866    |   0.0 |  0.17
Other   |            | 0.09663    |            |       |  0.02

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:      323040.0 ave      323040 max      323040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323040
Ave neighs/atom = 80.760000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.78369876487, Press = -0.202691642583036
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -13084.449   -13084.449   -13258.598   -13258.598    336.90262    336.90262    67590.286    67590.286   -545.24873   -545.24873 
   56000   -13087.802   -13087.802   -13261.089   -13261.089    335.23534    335.23534    67491.269    67491.269    280.17218    280.17218 
Loop time of 393.748 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.375 hours/ns, 2.540 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    | 392.84     | 392.84     | 392.84     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14169    | 0.14169    | 0.14169    |   0.0 |  0.04
Output  | 0.00048309 | 0.00048309 | 0.00048309 |   0.0 |  0.00
Modify  | 0.67115    | 0.67115    | 0.67115    |   0.0 |  0.17
Other   |            | 0.09583    |            |       |  0.02

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:      322678.0 ave      322678 max      322678 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322678
Ave neighs/atom = 80.669500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.836621237833, Press = 0.155756785781437
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -13087.802   -13087.802   -13261.089   -13261.089    335.23534    335.23534    67491.269    67491.269    280.17218    280.17218 
   57000   -13081.106   -13081.106   -13255.097   -13255.097    336.59708    336.59708    67596.661    67596.661   -336.05098   -336.05098 
Loop time of 414.006 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.209 ns/day, 115.002 hours/ns, 2.415 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    | 413.04     | 413.04     | 413.04     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14722    | 0.14722    | 0.14722    |   0.0 |  0.04
Output  | 0.0002818  | 0.0002818  | 0.0002818  |   0.0 |  0.00
Modify  | 0.72069    | 0.72069    | 0.72069    |   0.0 |  0.17
Other   |            | 0.09819    |            |       |  0.02

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:      323110.0 ave      323110 max      323110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323110
Ave neighs/atom = 80.777500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.867266821714, Press = -0.383534446450274
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -13081.106   -13081.106   -13255.097   -13255.097    336.59708    336.59708    67596.661    67596.661   -336.05098   -336.05098 
   58000   -13088.602   -13088.602   -13260.525   -13260.525    332.59675    332.59675    67525.097    67525.097   -27.620165   -27.620165 
Loop time of 418.123 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 116.145 hours/ns, 2.392 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    | 417.13     | 417.13     | 417.13     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1496     | 0.1496     | 0.1496     |   0.0 |  0.04
Output  | 0.00017977 | 0.00017977 | 0.00017977 |   0.0 |  0.00
Modify  | 0.73904    | 0.73904    | 0.73904    |   0.0 |  0.18
Other   |            | 0.1002     |            |       |  0.02

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:      322930.0 ave      322930 max      322930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322930
Ave neighs/atom = 80.732500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.897322952261, Press = 0.403677338323472
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -13088.602   -13088.602   -13260.525   -13260.525    332.59675    332.59675    67525.097    67525.097   -27.620165   -27.620165 
   59000   -13086.468   -13086.468   -13256.638   -13256.638    329.20457    329.20457    67530.761    67530.761    249.07894    249.07894 
Loop time of 393.215 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.227 hours/ns, 2.543 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 392.31     | 392.31     | 392.31     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14151    | 0.14151    | 0.14151    |   0.0 |  0.04
Output  | 0.00017867 | 0.00017867 | 0.00017867 |   0.0 |  0.00
Modify  | 0.67098    | 0.67098    | 0.67098    |   0.0 |  0.17
Other   |            | 0.09656    |            |       |  0.02

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:      322976.0 ave      322976 max      322976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322976
Ave neighs/atom = 80.744000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.919852463491, Press = -0.60237271326883
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -13086.468   -13086.468   -13256.638   -13256.638    329.20457    329.20457    67530.761    67530.761    249.07894    249.07894 
   60000    -13089.65    -13089.65   -13261.893   -13261.893    333.21485    333.21485     67556.69     67556.69    -451.0894    -451.0894 
Loop time of 393.086 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.191 hours/ns, 2.544 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 392.18     | 392.18     | 392.18     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14097    | 0.14097    | 0.14097    |   0.0 |  0.04
Output  | 0.00024038 | 0.00024038 | 0.00024038 |   0.0 |  0.00
Modify  | 0.67072    | 0.67072    | 0.67072    |   0.0 |  0.17
Other   |            | 0.09653    |            |       |  0.02

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:      323018.0 ave      323018 max      323018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323018
Ave neighs/atom = 80.754500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.929998101677, Press = 0.3297092239368
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000    -13089.65    -13089.65   -13261.893   -13261.893    333.21485    333.21485     67556.69     67556.69    -451.0894    -451.0894 
   61000   -13084.038   -13084.038   -13256.723   -13256.723    334.07094    334.07094    67474.586    67474.586    881.80305    881.80305 
Loop time of 393.544 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.318 hours/ns, 2.541 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 392.63     | 392.63     | 392.63     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14184    | 0.14184    | 0.14184    |   0.0 |  0.04
Output  | 0.0001782  | 0.0001782  | 0.0001782  |   0.0 |  0.00
Modify  | 0.67388    | 0.67388    | 0.67388    |   0.0 |  0.17
Other   |            | 0.09542    |            |       |  0.02

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:      322900.0 ave      322900 max      322900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322900
Ave neighs/atom = 80.725000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.912246348926, Press = -0.650064745767101
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -13084.038   -13084.038   -13256.723   -13256.723    334.07094    334.07094    67474.586    67474.586    881.80305    881.80305 
   62000   -13089.582   -13089.582   -13260.356   -13260.356    330.37394    330.37394    67645.936    67645.936   -1378.7511   -1378.7511 
Loop time of 398.353 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.217 ns/day, 110.654 hours/ns, 2.510 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    | 397.43     | 397.43     | 397.43     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14274    | 0.14274    | 0.14274    |   0.0 |  0.04
Output  | 0.0001754  | 0.0001754  | 0.0001754  |   0.0 |  0.00
Modify  | 0.68424    | 0.68424    | 0.68424    |   0.0 |  0.17
Other   |            | 0.09694    |            |       |  0.02

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:      323198.0 ave      323198 max      323198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323198
Ave neighs/atom = 80.799500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.912482886725, Press = 0.37402843088474
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -13089.582   -13089.582   -13260.356   -13260.356    330.37394    330.37394    67645.936    67645.936   -1378.7511   -1378.7511 
   63000   -13086.005   -13086.005   -13260.955   -13260.955    338.45212    338.45212    67494.128    67494.128    363.76237    363.76237 
Loop time of 394.282 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.523 hours/ns, 2.536 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    | 393.37     | 393.37     | 393.37     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14016    | 0.14016    | 0.14016    |   0.0 |  0.04
Output  | 0.00017888 | 0.00017888 | 0.00017888 |   0.0 |  0.00
Modify  | 0.67139    | 0.67139    | 0.67139    |   0.0 |  0.17
Other   |            | 0.0955     |            |       |  0.02

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:      322804.0 ave      322804 max      322804 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 322804
Ave neighs/atom = 80.701000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.923160660017, Press = -0.175460691840833
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -13086.005   -13086.005   -13260.955   -13260.955    338.45212    338.45212    67494.128    67494.128    363.76237    363.76237 
   64000   -13087.902   -13087.902   -13260.266   -13260.266    333.44931    333.44931    67580.951    67580.951   -622.98087   -622.98087 
Loop time of 393.272 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 109.242 hours/ns, 2.543 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    | 392.37     | 392.37     | 392.37     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14011    | 0.14011    | 0.14011    |   0.0 |  0.04
Output  | 0.00017662 | 0.00017662 | 0.00017662 |   0.0 |  0.00
Modify  | 0.66794    | 0.66794    | 0.66794    |   0.0 |  0.17
Other   |            | 0.09579    |            |       |  0.02

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:      323092.0 ave      323092 max      323092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 323092
Ave neighs/atom = 80.773000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.933114173131, Press = -0.140477243759967
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.610 | 4.610 | 4.610 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -13087.902   -13087.902   -13260.266   -13260.266    333.44931    333.44931    67580.951    67580.951   -622.98087   -622.98087 
   65000   -13084.725   -13084.725    -13260.34    -13260.34    339.74013    339.74013     67469.33     67469.33    705.65214    705.65214 
Loop time of 392.287 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 108.969 hours/ns, 2.549 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    | 391.38     | 391.38     | 391.38     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14109    | 0.14109    | 0.14109    |   0.0 |  0.04
Output  | 0.00017846 | 0.00017846 | 0.00017846 |   0.0 |  0.00
Modify  | 0.66832    | 0.66832    | 0.66832    |   0.0 |  0.17
Other   |            | 0.09479    |            |       |  0.02

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:      322844.0 ave      322844 max      322844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0