# 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 3.521391749382019*${_u_distance}
variable latticeconst_converted equal 3.521391749382019*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52139174938202
Lattice spacing in x,y,z = 3.5213917 3.5213917 3.5213917
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 (35.213917 35.213917 35.213917)
  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 (35.213917 35.213917 35.213917)
  create_atoms CPU = 0.001 seconds

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

kim_interactions Ni

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

kim interactions Ni
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_LeeShimBaskes_2003_Ni__MO_000553624872_000
pair_coeff * * Ni
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 58.6934

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 43665.9614516893 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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.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_000553624872_000#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17658.806   -17658.806       -17800       -17800       273.15       273.15    43665.961    43665.961    3453.7839    3453.7839 
    1000   -17508.577   -17508.577    -17657.58    -17657.58    288.25501    288.25501    44142.338    44142.338   -1595.3467   -1595.3467 
Loop time of 124.766 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.692 ns/day, 34.657 hours/ns, 8.015 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    | 124.35     | 124.35     | 124.35     |   0.0 | 99.66
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.053201   | 0.053201   | 0.053201   |   0.0 |  0.04
Output  | 0.00025128 | 0.00025128 | 0.00025128 |   0.0 |  0.00
Modify  | 0.31265    | 0.31265    | 0.31265    |   0.0 |  0.25
Other   |            | 0.0544     |            |       |  0.04

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

Total # of neighbors = 312000
Ave neighs/atom = 78.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17508.577   -17508.577    -17657.58    -17657.58    288.25501    288.25501    44142.338    44142.338   -1595.3467   -1595.3467 
    2000   -17517.097   -17517.097   -17655.248   -17655.248    267.26217    267.26217    44092.267    44092.267    513.45504    513.45504 
Loop time of 128.112 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 127.72     | 127.72     | 127.72     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049689   | 0.049689   | 0.049689   |   0.0 |  0.04
Output  | 0.00013603 | 0.00013603 | 0.00013603 |   0.0 |  0.00
Modify  | 0.29825    | 0.29825    | 0.29825    |   0.0 |  0.23
Other   |            | 0.04741    |            |       |  0.04

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

Total # of neighbors = 313692
Ave neighs/atom = 78.423000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17517.097   -17517.097   -17655.248   -17655.248    267.26217    267.26217    44092.267    44092.267    513.45504    513.45504 
    3000   -17516.726   -17516.726    -17657.17    -17657.17    271.69951    271.69951    44091.073    44091.073    359.78575    359.78575 
Loop time of 127.004 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.680 ns/day, 35.279 hours/ns, 7.874 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    | 126.61     | 126.61     | 126.61     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049437   | 0.049437   | 0.049437   |   0.0 |  0.04
Output  | 0.00014436 | 0.00014436 | 0.00014436 |   0.0 |  0.00
Modify  | 0.29711    | 0.29711    | 0.29711    |   0.0 |  0.23
Other   |            | 0.04926    |            |       |  0.04

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

Total # of neighbors = 313914
Ave neighs/atom = 78.478500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17516.726   -17516.726    -17657.17    -17657.17    271.69951    271.69951    44091.073    44091.073    359.78575    359.78575 
    4000   -17513.956   -17513.956   -17654.336   -17654.336    271.57441    271.57441    44109.023    44109.023   -41.664597   -41.664597 
Loop time of 128.406 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 128        | 128        | 128        |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.049935   | 0.049935   | 0.049935   |   0.0 |  0.04
Output  | 0.0001352  | 0.0001352  | 0.0001352  |   0.0 |  0.00
Modify  | 0.30116    | 0.30116    | 0.30116    |   0.0 |  0.23
Other   |            | 0.0504     |            |       |  0.04

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

Total # of neighbors = 313942
Ave neighs/atom = 78.485500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17513.956   -17513.956   -17654.336   -17654.336    271.57441    271.57441    44109.023    44109.023   -41.664597   -41.664597 
    5000   -17518.161   -17518.161   -17659.478   -17659.478    273.38583    273.38583    44103.642    44103.642   -295.97874   -295.97874 
Loop time of 125.418 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.689 ns/day, 34.838 hours/ns, 7.973 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.03     | 125.03     | 125.03     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047444   | 0.047444   | 0.047444   |   0.0 |  0.04
Output  | 0.0001043  | 0.0001043  | 0.0001043  |   0.0 |  0.00
Modify  | 0.29239    | 0.29239    | 0.29239    |   0.0 |  0.23
Other   |            | 0.04646    |            |       |  0.04

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

Total # of neighbors = 313854
Ave neighs/atom = 78.463500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 270.611136067679, Press = -333.668789490264
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17518.161   -17518.161   -17659.478   -17659.478    273.38583    273.38583    44103.642    44103.642   -295.97874   -295.97874 
    6000   -17512.851   -17512.851   -17654.119   -17654.119    273.29247    273.29247    44060.629    44060.629    2027.4793    2027.4793 
Loop time of 126.147 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.685 ns/day, 35.041 hours/ns, 7.927 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.75     | 125.75     | 125.75     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047688   | 0.047688   | 0.047688   |   0.0 |  0.04
Output  | 0.00022206 | 0.00022206 | 0.00022206 |   0.0 |  0.00
Modify  | 0.30303    | 0.30303    | 0.30303    |   0.0 |  0.24
Other   |            | 0.04694    |            |       |  0.04

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

Total # of neighbors = 313804
Ave neighs/atom = 78.451000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.788199622969, Press = 6.19617746541555
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17512.851   -17512.851   -17654.119   -17654.119    273.29247    273.29247    44060.629    44060.629    2027.4793    2027.4793 
    7000   -17518.113   -17518.113   -17657.601   -17657.601    269.84982    269.84982    44152.994    44152.994   -2174.9727   -2174.9727 
Loop time of 125.251 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.690 ns/day, 34.792 hours/ns, 7.984 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.86     | 124.86     | 124.86     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047551   | 0.047551   | 0.047551   |   0.0 |  0.04
Output  | 0.0001021  | 0.0001021  | 0.0001021  |   0.0 |  0.00
Modify  | 0.3008     | 0.3008     | 0.3008     |   0.0 |  0.24
Other   |            | 0.04643    |            |       |  0.04

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

Total # of neighbors = 314060
Ave neighs/atom = 78.515000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.017667461471, Press = 7.4225075888593
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17518.113   -17518.113   -17657.601   -17657.601    269.84982    269.84982    44152.994    44152.994   -2174.9727   -2174.9727 
    8000   -17515.198   -17515.198   -17660.324   -17660.324    280.75567    280.75567    44097.634    44097.634   -104.30626   -104.30626 
Loop time of 133.18 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.649 ns/day, 36.994 hours/ns, 7.509 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 132.75     | 132.75     | 132.75     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.050041   | 0.050041   | 0.050041   |   0.0 |  0.04
Output  | 0.0001038  | 0.0001038  | 0.0001038  |   0.0 |  0.00
Modify  | 0.32353    | 0.32353    | 0.32353    |   0.0 |  0.24
Other   |            | 0.05149    |            |       |  0.04

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

Total # of neighbors = 313778
Ave neighs/atom = 78.444500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.964957614613, Press = -22.1650930774426
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17515.198   -17515.198   -17660.324   -17660.324    280.75567    280.75567    44097.634    44097.634   -104.30626   -104.30626 
    9000   -17519.002   -17519.002   -17659.503   -17659.503    271.80965    271.80965    44081.577    44081.577    584.35344    584.35344 
Loop time of 126.162 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.685 ns/day, 35.045 hours/ns, 7.926 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.76     | 125.76     | 125.76     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047872   | 0.047872   | 0.047872   |   0.0 |  0.04
Output  | 0.00010523 | 0.00010523 | 0.00010523 |   0.0 |  0.00
Modify  | 0.30242    | 0.30242    | 0.30242    |   0.0 |  0.24
Other   |            | 0.04695    |            |       |  0.04

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

Total # of neighbors = 313732
Ave neighs/atom = 78.433000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.602525308007, Press = 1.69507515286412
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17519.002   -17519.002   -17659.503   -17659.503    271.80965    271.80965    44081.577    44081.577    584.35344    584.35344 
   10000   -17509.556   -17509.556   -17653.353   -17653.353    278.18345    278.18345    44139.015    44139.015   -1088.1294   -1088.1294 
Loop time of 125.476 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.689 ns/day, 34.854 hours/ns, 7.970 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.08     | 125.08     | 125.08     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047413   | 0.047413   | 0.047413   |   0.0 |  0.04
Output  | 0.00021749 | 0.00021749 | 0.00021749 |   0.0 |  0.00
Modify  | 0.29901    | 0.29901    | 0.29901    |   0.0 |  0.24
Other   |            | 0.04607    |            |       |  0.04

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

Total # of neighbors = 313794
Ave neighs/atom = 78.448500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.920793401586, Press = -2.82756535591628
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17509.556   -17509.556   -17653.353   -17653.353    278.18345    278.18345    44139.015    44139.015   -1088.1294   -1088.1294 
   11000    -17517.61    -17517.61   -17654.684   -17654.684    265.17785    265.17785    44083.794    44083.794    857.98891    857.98891 
Loop time of 125.095 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.691 ns/day, 34.749 hours/ns, 7.994 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.7      | 124.7      | 124.7      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047334   | 0.047334   | 0.047334   |   0.0 |  0.04
Output  | 0.00010534 | 0.00010534 | 0.00010534 |   0.0 |  0.00
Modify  | 0.29831    | 0.29831    | 0.29831    |   0.0 |  0.24
Other   |            | 0.04633    |            |       |  0.04

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

Total # of neighbors = 313740
Ave neighs/atom = 78.435000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.111360594062, Press = -5.0688825434167
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -17517.61    -17517.61   -17654.684   -17654.684    265.17785    265.17785    44083.794    44083.794    857.98891    857.98891 
   12000   -17519.845   -17519.845    -17660.93    -17660.93    272.93849    272.93849    44077.693    44077.693    626.52294    626.52294 
Loop time of 125.359 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.689 ns/day, 34.822 hours/ns, 7.977 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.96     | 124.96     | 124.96     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047686   | 0.047686   | 0.047686   |   0.0 |  0.04
Output  | 0.000215   | 0.000215   | 0.000215   |   0.0 |  0.00
Modify  | 0.30072    | 0.30072    | 0.30072    |   0.0 |  0.24
Other   |            | 0.04765    |            |       |  0.04

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

Total # of neighbors = 313876
Ave neighs/atom = 78.469000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.170097886508, Press = 6.06937368779868
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17519.845   -17519.845    -17660.93    -17660.93    272.93849    272.93849    44077.693    44077.693    626.52294    626.52294 
   13000   -17515.301   -17515.301   -17658.844   -17658.844    277.69305    277.69305    44168.987    44168.987   -2879.6145   -2879.6145 
Loop time of 125.693 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.687 ns/day, 34.915 hours/ns, 7.956 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.3      | 125.3      | 125.3      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047252   | 0.047252   | 0.047252   |   0.0 |  0.04
Output  | 0.00010482 | 0.00010482 | 0.00010482 |   0.0 |  0.00
Modify  | 0.29985    | 0.29985    | 0.29985    |   0.0 |  0.24
Other   |            | 0.04592    |            |       |  0.04

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

Total # of neighbors = 313796
Ave neighs/atom = 78.449000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.041612279863, Press = -4.17412841908287
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17515.301   -17515.301   -17658.844   -17658.844    277.69305    277.69305    44168.987    44168.987   -2879.6145   -2879.6145 
   14000   -17520.901   -17520.901    -17661.44    -17661.44     271.8836     271.8836    44067.126    44067.126    971.66706    971.66706 
Loop time of 125.183 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.690 ns/day, 34.773 hours/ns, 7.988 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.79     | 124.79     | 124.79     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047311   | 0.047311   | 0.047311   |   0.0 |  0.04
Output  | 0.00010565 | 0.00010565 | 0.00010565 |   0.0 |  0.00
Modify  | 0.30038    | 0.30038    | 0.30038    |   0.0 |  0.24
Other   |            | 0.04584    |            |       |  0.04

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

Total # of neighbors = 313650
Ave neighs/atom = 78.412500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.838286511609, Press = -4.4297047811557
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17520.901   -17520.901    -17661.44    -17661.44     271.8836     271.8836    44067.126    44067.126    971.66706    971.66706 
   15000    -17517.76    -17517.76   -17657.375   -17657.375    270.09615    270.09615    44096.825    44096.825    151.90687    151.90687 
Loop time of 126.939 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.681 ns/day, 35.261 hours/ns, 7.878 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    | 126.54     | 126.54     | 126.54     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048361   | 0.048361   | 0.048361   |   0.0 |  0.04
Output  | 0.00021612 | 0.00021612 | 0.00021612 |   0.0 |  0.00
Modify  | 0.30464    | 0.30464    | 0.30464    |   0.0 |  0.24
Other   |            | 0.04712    |            |       |  0.04

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

Total # of neighbors = 313742
Ave neighs/atom = 78.435500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.824923862403, Press = 1.52589211930999
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -17517.76    -17517.76   -17657.375   -17657.375    270.09615    270.09615    44096.825    44096.825    151.90687    151.90687 
   16000   -17513.577   -17513.577   -17658.038   -17658.038     279.4691     279.4691    44126.699    44126.699    -1048.809    -1048.809 
Loop time of 126.147 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.685 ns/day, 35.041 hours/ns, 7.927 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.75     | 125.75     | 125.75     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048127   | 0.048127   | 0.048127   |   0.0 |  0.04
Output  | 0.00010487 | 0.00010487 | 0.00010487 |   0.0 |  0.00
Modify  | 0.30293    | 0.30293    | 0.30293    |   0.0 |  0.24
Other   |            | 0.04714    |            |       |  0.04

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

Total # of neighbors = 313812
Ave neighs/atom = 78.453000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.76689790124, Press = -2.13168307932296
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17513.577   -17513.577   -17658.038   -17658.038     279.4691     279.4691    44126.699    44126.699    -1048.809    -1048.809 
   17000   -17520.535   -17520.535   -17660.336   -17660.336    270.45626    270.45626    44076.721    44076.721     638.3887     638.3887 
Loop time of 125.874 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.686 ns/day, 34.965 hours/ns, 7.944 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.48     | 125.48     | 125.48     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047913   | 0.047913   | 0.047913   |   0.0 |  0.04
Output  | 0.00010128 | 0.00010128 | 0.00010128 |   0.0 |  0.00
Modify  | 0.30104    | 0.30104    | 0.30104    |   0.0 |  0.24
Other   |            | 0.04652    |            |       |  0.04

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

Total # of neighbors = 313638
Ave neighs/atom = 78.409500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.733403814057, Press = -2.64208325842267
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17520.535   -17520.535   -17660.336   -17660.336    270.45626    270.45626    44076.721    44076.721     638.3887     638.3887 
   18000   -17514.937   -17514.937   -17657.561   -17657.561    275.91428    275.91428    44070.081    44070.081    1203.1522    1203.1522 
Loop time of 127.358 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.678 ns/day, 35.377 hours/ns, 7.852 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 126.95     | 126.95     | 126.95     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.048201   | 0.048201   | 0.048201   |   0.0 |  0.04
Output  | 0.00011009 | 0.00011009 | 0.00011009 |   0.0 |  0.00
Modify  | 0.30754    | 0.30754    | 0.30754    |   0.0 |  0.24
Other   |            | 0.04771    |            |       |  0.04

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

Total # of neighbors = 313840
Ave neighs/atom = 78.460000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.662610243662, Press = 3.64218788363971
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17514.937   -17514.937   -17657.561   -17657.561    275.91428    275.91428    44070.081    44070.081    1203.1522    1203.1522 
   19000   -17518.092   -17518.092   -17658.704   -17658.704    272.02323    272.02323    44151.325    44151.325   -2256.7228   -2256.7228 
Loop time of 124.897 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.692 ns/day, 34.694 hours/ns, 8.007 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.51     | 124.51     | 124.51     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047273   | 0.047273   | 0.047273   |   0.0 |  0.04
Output  | 0.00022508 | 0.00022508 | 0.00022508 |   0.0 |  0.00
Modify  | 0.29718    | 0.29718    | 0.29718    |   0.0 |  0.24
Other   |            | 0.04575    |            |       |  0.04

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

Total # of neighbors = 313900
Ave neighs/atom = 78.475000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.633059023776, Press = -2.1292266376441
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17518.092   -17518.092   -17658.704   -17658.704    272.02323    272.02323    44151.325    44151.325   -2256.7228   -2256.7228 
   20000   -17514.864   -17514.864   -17655.588   -17655.588    272.23851    272.23851     44073.67     44073.67    1307.0588    1307.0588 
Loop time of 125.43 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.689 ns/day, 34.842 hours/ns, 7.973 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 125.03     | 125.03     | 125.03     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047813   | 0.047813   | 0.047813   |   0.0 |  0.04
Output  | 0.00010249 | 0.00010249 | 0.00010249 |   0.0 |  0.00
Modify  | 0.30138    | 0.30138    | 0.30138    |   0.0 |  0.24
Other   |            | 0.048      |            |       |  0.04

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

Total # of neighbors = 313618
Ave neighs/atom = 78.404500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.662097373083, Press = -1.98690338547308
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17514.864   -17514.864   -17655.588   -17655.588    272.23851    272.23851     44073.67     44073.67    1307.0588    1307.0588 
   21000   -17515.996   -17515.996   -17660.029   -17660.029    278.64198    278.64198    44104.894    44104.894   -388.72332   -388.72332 
Loop time of 126.773 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.682 ns/day, 35.215 hours/ns, 7.888 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    | 126.37     | 126.37     | 126.37     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04786    | 0.04786    | 0.04786    |   0.0 |  0.04
Output  | 0.00010016 | 0.00010016 | 0.00010016 |   0.0 |  0.00
Modify  | 0.30376    | 0.30376    | 0.30376    |   0.0 |  0.24
Other   |            | 0.04733    |            |       |  0.04

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

Total # of neighbors = 313932
Ave neighs/atom = 78.483000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.677777983191, Press = 1.31819642542428
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17515.996   -17515.996   -17660.029   -17660.029    278.64198    278.64198    44104.894    44104.894   -388.72332   -388.72332 
   22000   -17521.574   -17521.574   -17660.712   -17660.712    269.17125    269.17125    44110.705    44110.705    -816.3602    -816.3602 
Loop time of 124.875 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.692 ns/day, 34.688 hours/ns, 8.008 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.48     | 124.48     | 124.48     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047263   | 0.047263   | 0.047263   |   0.0 |  0.04
Output  | 0.00010406 | 0.00010406 | 0.00010406 |   0.0 |  0.00
Modify  | 0.2977     | 0.2977     | 0.2977     |   0.0 |  0.24
Other   |            | 0.04626    |            |       |  0.04

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

Total # of neighbors = 313716
Ave neighs/atom = 78.429000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.692533695487, Press = -1.39030761398488
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17521.574   -17521.574   -17660.712   -17660.712    269.17125    269.17125    44110.705    44110.705    -816.3602    -816.3602 
   23000   -17515.883   -17515.883   -17657.684   -17657.684    274.32354    274.32354    44091.584    44091.584    339.45343    339.45343 
Loop time of 124.664 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.693 ns/day, 34.629 hours/ns, 8.022 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.27     | 124.27     | 124.27     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047067   | 0.047067   | 0.047067   |   0.0 |  0.04
Output  | 0.00010119 | 0.00010119 | 0.00010119 |   0.0 |  0.00
Modify  | 0.29826    | 0.29826    | 0.29826    |   0.0 |  0.24
Other   |            | 0.04573    |            |       |  0.04

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

Total # of neighbors = 313710
Ave neighs/atom = 78.427500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.671133548631, Press = -0.556200806219902
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17515.883   -17515.883   -17657.684   -17657.684    274.32354    274.32354    44091.584    44091.584    339.45343    339.45343 
   24000   -17516.485   -17516.485   -17658.089   -17658.089     273.9433     273.9433    44105.192    44105.192   -292.85173   -292.85173 
Loop time of 125.216 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.690 ns/day, 34.782 hours/ns, 7.986 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.82     | 124.82     | 124.82     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047377   | 0.047377   | 0.047377   |   0.0 |  0.04
Output  | 0.00010242 | 0.00010242 | 0.00010242 |   0.0 |  0.00
Modify  | 0.29915    | 0.29915    | 0.29915    |   0.0 |  0.24
Other   |            | 0.04832    |            |       |  0.04

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

Total # of neighbors = 313826
Ave neighs/atom = 78.456500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.659409945804, Press = -0.149488948507818
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17516.485   -17516.485   -17658.089   -17658.089     273.9433     273.9433    44105.192    44105.192   -292.85173   -292.85173 
   25000   -17515.604   -17515.604   -17656.068   -17656.068    271.73842    271.73842    44111.795    44111.795   -377.40794   -377.40794 
Loop time of 124.57 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.694 ns/day, 34.603 hours/ns, 8.028 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.18     | 124.18     | 124.18     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047298   | 0.047298   | 0.047298   |   0.0 |  0.04
Output  | 0.00010479 | 0.00010479 | 0.00010479 |   0.0 |  0.00
Modify  | 0.29911    | 0.29911    | 0.29911    |   0.0 |  0.24
Other   |            | 0.04694    |            |       |  0.04

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

Total # of neighbors = 313816
Ave neighs/atom = 78.454000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.735557721583, Press = -0.865519311387974
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17515.604   -17515.604   -17656.068   -17656.068    271.73842    271.73842    44111.795    44111.795   -377.40794   -377.40794 
   26000   -17518.555   -17518.555   -17656.217   -17656.217    266.31719    266.31719    44076.029    44076.029    1063.5037    1063.5037 
Loop time of 124.713 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.693 ns/day, 34.642 hours/ns, 8.018 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.32     | 124.32     | 124.32     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047137   | 0.047137   | 0.047137   |   0.0 |  0.04
Output  | 0.00010377 | 0.00010377 | 0.00010377 |   0.0 |  0.00
Modify  | 0.2992     | 0.2992     | 0.2992     |   0.0 |  0.24
Other   |            | 0.04613    |            |       |  0.04

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

Total # of neighbors = 313800
Ave neighs/atom = 78.450000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.821083677785, Press = -1.41342136938494
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17518.555   -17518.555   -17656.217   -17656.217    266.31719    266.31719    44076.029    44076.029    1063.5037    1063.5037 
   27000   -17519.585   -17519.585   -17660.255   -17660.255    272.13638    272.13638    44101.146    44101.146   -397.44523   -397.44523 
Loop time of 124.81 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.692 ns/day, 34.669 hours/ns, 8.012 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.42     | 124.42     | 124.42     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047528   | 0.047528   | 0.047528   |   0.0 |  0.04
Output  | 0.00010657 | 0.00010657 | 0.00010657 |   0.0 |  0.00
Modify  | 0.2999     | 0.2999     | 0.2999     |   0.0 |  0.24
Other   |            | 0.04611    |            |       |  0.04

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

Total # of neighbors = 313906
Ave neighs/atom = 78.476500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.848791993753, Press = 0.984861313889731
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17519.585   -17519.585   -17660.255   -17660.255    272.13638    272.13638    44101.146    44101.146   -397.44523   -397.44523 
   28000    -17515.27    -17515.27   -17656.266   -17656.266    272.76674    272.76674    44135.557    44135.557   -1380.6738   -1380.6738 
Loop time of 124.974 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.691 ns/day, 34.715 hours/ns, 8.002 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.58     | 124.58     | 124.58     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047272   | 0.047272   | 0.047272   |   0.0 |  0.04
Output  | 0.00010434 | 0.00010434 | 0.00010434 |   0.0 |  0.00
Modify  | 0.30028    | 0.30028    | 0.30028    |   0.0 |  0.24
Other   |            | 0.0462     |            |       |  0.04

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

Total # of neighbors = 313882
Ave neighs/atom = 78.470500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.811536229368, Press = -2.45048214458166
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -17515.27    -17515.27   -17656.266   -17656.266    272.76674    272.76674    44135.557    44135.557   -1380.6738   -1380.6738 
   29000    -17521.11    -17521.11   -17658.617   -17658.617    266.01732    266.01732    44039.518    44039.518    2339.1686    2339.1686 
Loop time of 125.017 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.691 ns/day, 34.727 hours/ns, 7.999 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.62     | 124.62     | 124.62     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.047404   | 0.047404   | 0.047404   |   0.0 |  0.04
Output  | 0.0001064  | 0.0001064  | 0.0001064  |   0.0 |  0.00
Modify  | 0.29988    | 0.29988    | 0.29988    |   0.0 |  0.24
Other   |            | 0.04599    |            |       |  0.04

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

Total # of neighbors = 313814
Ave neighs/atom = 78.453500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.767676818098, Press = -0.838200459973568
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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    -17521.11    -17521.11   -17658.617   -17658.617    266.01732    266.01732    44039.518    44039.518    2339.1686    2339.1686 
   30000   -17517.489   -17517.489   -17657.557   -17657.557    270.97171    270.97171    44107.511    44107.511   -391.53374   -391.53374 
Loop time of 124.551 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.694 ns/day, 34.597 hours/ns, 8.029 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.17     | 124.17     | 124.17     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046643   | 0.046643   | 0.046643   |   0.0 |  0.04
Output  | 0.00012311 | 0.00012311 | 0.00012311 |   0.0 |  0.00
Modify  | 0.29198    | 0.29198    | 0.29198    |   0.0 |  0.23
Other   |            | 0.04245    |            |       |  0.03

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

Total # of neighbors = 313886
Ave neighs/atom = 78.471500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.772481274443, Press = 0.619045523894029
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17517.489   -17517.489   -17657.557   -17657.557    270.97171    270.97171    44107.511    44107.511   -391.53374   -391.53374 
   31000   -17511.068   -17511.068   -17654.126   -17654.126    276.75569    276.75569    44110.839    44110.839   -79.024587   -79.024587 
Loop time of 124.637 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.693 ns/day, 34.621 hours/ns, 8.023 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.26     | 124.26     | 124.26     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046479   | 0.046479   | 0.046479   |   0.0 |  0.04
Output  | 9.9923e-05 | 9.9923e-05 | 9.9923e-05 |   0.0 |  0.00
Modify  | 0.29235    | 0.29235    | 0.29235    |   0.0 |  0.23
Other   |            | 0.04255    |            |       |  0.03

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

Total # of neighbors = 313788
Ave neighs/atom = 78.447000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.816483364212, Press = -1.13705440838049
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17511.068   -17511.068   -17654.126   -17654.126    276.75569    276.75569    44110.839    44110.839   -79.024587   -79.024587 
   32000   -17516.739   -17516.739   -17657.827   -17657.827    272.94541    272.94541    44088.271    44088.271    362.14527    362.14527 
Loop time of 124.693 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.693 ns/day, 34.637 hours/ns, 8.020 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.31     | 124.31     | 124.31     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046265   | 0.046265   | 0.046265   |   0.0 |  0.04
Output  | 0.0001029  | 0.0001029  | 0.0001029  |   0.0 |  0.00
Modify  | 0.29157    | 0.29157    | 0.29157    |   0.0 |  0.23
Other   |            | 0.04225    |            |       |  0.03

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

Total # of neighbors = 313938
Ave neighs/atom = 78.484500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.856081793027, Press = -0.309272637894999
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17516.739   -17516.739   -17657.827   -17657.827    272.94541    272.94541    44088.271    44088.271    362.14527    362.14527 
   33000   -17511.809   -17511.809   -17654.959   -17654.959    276.93409    276.93409    44130.775    44130.775   -1024.3935   -1024.3935 
Loop time of 124.652 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.693 ns/day, 34.626 hours/ns, 8.022 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.27     | 124.27     | 124.27     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04648    | 0.04648    | 0.04648    |   0.0 |  0.04
Output  | 0.00010566 | 0.00010566 | 0.00010566 |   0.0 |  0.00
Modify  | 0.2921     | 0.2921     | 0.2921     |   0.0 |  0.23
Other   |            | 0.04247    |            |       |  0.03

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

Total # of neighbors = 313818
Ave neighs/atom = 78.454500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.938645704217, Press = -0.453404291040394
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17511.809   -17511.809   -17654.959   -17654.959    276.93409    276.93409    44130.775    44130.775   -1024.3935   -1024.3935 
   34000   -17514.042   -17514.042   -17655.363   -17655.363    273.39687    273.39687    44090.769    44090.769    632.25609    632.25609 
Loop time of 124.552 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.694 ns/day, 34.598 hours/ns, 8.029 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.17     | 124.17     | 124.17     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046603   | 0.046603   | 0.046603   |   0.0 |  0.04
Output  | 0.00010128 | 0.00010128 | 0.00010128 |   0.0 |  0.00
Modify  | 0.29242    | 0.29242    | 0.29242    |   0.0 |  0.23
Other   |            | 0.04308    |            |       |  0.03

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

Total # of neighbors = 313810
Ave neighs/atom = 78.452500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.92725544899, Press = -2.58204860119186
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17514.042   -17514.042   -17655.363   -17655.363    273.39687    273.39687    44090.769    44090.769    632.25609    632.25609 
   35000   -17518.755   -17518.755    -17657.89    -17657.89     269.1652     269.1652    44058.052    44058.052    1631.0227    1631.0227 
Loop time of 124.714 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.693 ns/day, 34.643 hours/ns, 8.018 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.33     | 124.33     | 124.33     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046452   | 0.046452   | 0.046452   |   0.0 |  0.04
Output  | 0.00010218 | 0.00010218 | 0.00010218 |   0.0 |  0.00
Modify  | 0.29174    | 0.29174    | 0.29174    |   0.0 |  0.23
Other   |            | 0.04265    |            |       |  0.03

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

Total # of neighbors = 313890
Ave neighs/atom = 78.472500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.964686242805, Press = 1.29499774062638
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17518.755   -17518.755    -17657.89    -17657.89     269.1652     269.1652    44058.052    44058.052    1631.0227    1631.0227 
   36000   -17513.491   -17513.491   -17655.893   -17655.893    275.48672    275.48672    44142.738    44142.738   -1545.9414   -1545.9414 
Loop time of 124.502 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.694 ns/day, 34.584 hours/ns, 8.032 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.12     | 124.12     | 124.12     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046692   | 0.046692   | 0.046692   |   0.0 |  0.04
Output  | 0.00010036 | 0.00010036 | 0.00010036 |   0.0 |  0.00
Modify  | 0.29191    | 0.29191    | 0.29191    |   0.0 |  0.23
Other   |            | 0.04254    |            |       |  0.03

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

Total # of neighbors = 313954
Ave neighs/atom = 78.488500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.012567634854, Press = -0.436648202123234
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17513.491   -17513.491   -17655.893   -17655.893    275.48672    275.48672    44142.738    44142.738   -1545.9414   -1545.9414 
   37000   -17518.652   -17518.652   -17658.403   -17658.403    270.35723    270.35723     44085.35     44085.35    520.09237    520.09237 
Loop time of 124.456 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.694 ns/day, 34.571 hours/ns, 8.035 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.08     | 124.08     | 124.08     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046182   | 0.046182   | 0.046182   |   0.0 |  0.04
Output  | 0.00010168 | 0.00010168 | 0.00010168 |   0.0 |  0.00
Modify  | 0.2916     | 0.2916     | 0.2916     |   0.0 |  0.23
Other   |            | 0.0424     |            |       |  0.03

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

Total # of neighbors = 313840
Ave neighs/atom = 78.460000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.039843550475, Press = -1.21314996694856
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17518.652   -17518.652   -17658.403   -17658.403    270.35723    270.35723     44085.35     44085.35    520.09237    520.09237 
   38000   -17512.748   -17512.748   -17655.881   -17655.881    276.90018    276.90018    44098.356    44098.356    250.42677    250.42677 
Loop time of 124.646 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.693 ns/day, 34.624 hours/ns, 8.023 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.26     | 124.26     | 124.26     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046498   | 0.046498   | 0.046498   |   0.0 |  0.04
Output  | 0.00010067 | 0.00010067 | 0.00010067 |   0.0 |  0.00
Modify  | 0.29163    | 0.29163    | 0.29163    |   0.0 |  0.23
Other   |            | 0.04261    |            |       |  0.03

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

Total # of neighbors = 313842
Ave neighs/atom = 78.460500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.047344210617, Press = 0.263861970799605
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17512.748   -17512.748   -17655.881   -17655.881    276.90018    276.90018    44098.356    44098.356    250.42677    250.42677 
   39000   -17515.805   -17515.805   -17656.523   -17656.523    272.22847    272.22847    44116.279    44116.279   -542.58121   -542.58121 
Loop time of 124.664 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.693 ns/day, 34.629 hours/ns, 8.022 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.28     | 124.28     | 124.28     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04645    | 0.04645    | 0.04645    |   0.0 |  0.04
Output  | 0.00011059 | 0.00011059 | 0.00011059 |   0.0 |  0.00
Modify  | 0.29186    | 0.29186    | 0.29186    |   0.0 |  0.23
Other   |            | 0.04258    |            |       |  0.03

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

Total # of neighbors = 313916
Ave neighs/atom = 78.479000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.048090829183, Press = -0.659025224832249
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17515.805   -17515.805   -17656.523   -17656.523    272.22847    272.22847    44116.279    44116.279   -542.58121   -542.58121 
   40000   -17517.135   -17517.135   -17657.762   -17657.762    272.05312    272.05312    44073.531    44073.531    1027.2913    1027.2913 
Loop time of 124.627 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.693 ns/day, 34.619 hours/ns, 8.024 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.24     | 124.24     | 124.24     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046786   | 0.046786   | 0.046786   |   0.0 |  0.04
Output  | 0.00010292 | 0.00010292 | 0.00010292 |   0.0 |  0.00
Modify  | 0.29337    | 0.29337    | 0.29337    |   0.0 |  0.24
Other   |            | 0.04408    |            |       |  0.04

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

Total # of neighbors = 313726
Ave neighs/atom = 78.431500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.04811235153, Press = -0.996524460179803
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17517.135   -17517.135   -17657.762   -17657.762    272.05312    272.05312    44073.531    44073.531    1027.2913    1027.2913 
   41000   -17517.584   -17517.584   -17656.551   -17656.551    268.84076    268.84076     44081.55     44081.55    825.14223    825.14223 
Loop time of 124.379 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.695 ns/day, 34.550 hours/ns, 8.040 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124        | 124        | 124        |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046241   | 0.046241   | 0.046241   |   0.0 |  0.04
Output  | 0.00010133 | 0.00010133 | 0.00010133 |   0.0 |  0.00
Modify  | 0.29139    | 0.29139    | 0.29139    |   0.0 |  0.23
Other   |            | 0.04242    |            |       |  0.03

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

Total # of neighbors = 313812
Ave neighs/atom = 78.453000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.073227395938, Press = 1.53849523742321
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17517.584   -17517.584   -17656.551   -17656.551    268.84076    268.84076     44081.55     44081.55    825.14223    825.14223 
   42000   -17514.178   -17514.178   -17654.096   -17654.096    270.68096    270.68096    44150.648    44150.648   -1862.6419   -1862.6419 
Loop time of 124.206 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.696 ns/day, 34.502 hours/ns, 8.051 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 123.82     | 123.82     | 123.82     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046411   | 0.046411   | 0.046411   |   0.0 |  0.04
Output  | 0.00010131 | 0.00010131 | 0.00010131 |   0.0 |  0.00
Modify  | 0.29195    | 0.29195    | 0.29195    |   0.0 |  0.24
Other   |            | 0.04259    |            |       |  0.03

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

Total # of neighbors = 313874
Ave neighs/atom = 78.468500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.043059668379, Press = -1.05132632545274
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17514.178   -17514.178   -17654.096   -17654.096    270.68096    270.68096    44150.648    44150.648   -1862.6419   -1862.6419 
   43000   -17519.861   -17519.861   -17657.314   -17657.314    265.91265    265.91265    44073.217    44073.217    996.48379    996.48379 
Loop time of 124.529 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.694 ns/day, 34.591 hours/ns, 8.030 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.15     | 124.15     | 124.15     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.04642    | 0.04642    | 0.04642    |   0.0 |  0.04
Output  | 0.00010221 | 0.00010221 | 0.00010221 |   0.0 |  0.00
Modify  | 0.29189    | 0.29189    | 0.29189    |   0.0 |  0.23
Other   |            | 0.04257    |            |       |  0.03

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

Total # of neighbors = 313794
Ave neighs/atom = 78.448500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.015043073676, Press = -0.758121573025897
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 12 12 12
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 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   -17519.861   -17519.861   -17657.314   -17657.314    265.91265    265.91265    44073.217    44073.217    996.48379    996.48379 
   44000   -17513.147   -17513.147   -17654.737   -17654.737    273.91539    273.91539    44105.792    44105.792    19.697846    19.697846 
Loop time of 124.59 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.693 ns/day, 34.608 hours/ns, 8.026 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 124.21     | 124.21     | 124.21     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.046423   | 0.046423   | 0.046423   |   0.0 |  0.04
Output  | 0.0001008  | 0.0001008  | 0.0001008  |   0.0 |  0.00
Modify  | 0.29177    | 0.29177    | 0.29177    |   0.0 |  0.23
Other   |            | 0.04264    |            |       |  0.03

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

Total # of neighbors = 313912
Ave neighs/atom = 78.478000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
44100.9392148132

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0