# 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.5213917419314393*${_u_distance}
variable latticeconst_converted equal 3.5213917419314393*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.52139174193144
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.003 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_KoGrabowskiNeugebauer_2015_NiTi__MO_663355627503_001
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.9611745232    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9611745232/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9611745232/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 43665.9611745232/(1*1*${_u_distance})
variable      V0_metal equal 43665.9611745232/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 43665.9611745232*1000

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.370 | 5.370 | 5.370 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -17648.467   -17648.467       -17800       -17800       293.15       293.15    43665.961    43665.961    3706.6528    3706.6528 
    1000   -17487.218   -17487.218   -17639.074   -17639.074    293.77608    293.77608    44098.105    44098.105     1723.188     1723.188 
Loop time of 398.426 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.217 ns/day, 110.674 hours/ns, 2.510 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 397.52     | 397.52     | 397.52     |   0.0 | 99.77
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14737    | 0.14737    | 0.14737    |   0.0 |  0.04
Output  | 0.00022944 | 0.00022944 | 0.00022944 |   0.0 |  0.00
Modify  | 0.667      | 0.667      | 0.667      |   0.0 |  0.17
Other   |            | 0.09594    |            |       |  0.02

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

Total # of neighbors = 536000
Ave neighs/atom = 134.00000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -17487.218   -17487.218   -17639.074   -17639.074    293.77608    293.77608    44098.105    44098.105     1723.188     1723.188 
    2000   -17496.169   -17496.169   -17648.973   -17648.973     295.6098     295.6098    44114.802    44114.802      144.575      144.575 
Loop time of 390.874 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.576 hours/ns, 2.558 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    | 389.94     | 389.94     | 389.94     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15659    | 0.15659    | 0.15659    |   0.0 |  0.04
Output  | 0.00021037 | 0.00021037 | 0.00021037 |   0.0 |  0.00
Modify  | 0.68135    | 0.68135    | 0.68135    |   0.0 |  0.17
Other   |            | 0.09641    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6164.00 ave        6164 max        6164 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541266.0 ave      541266 max      541266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541266
Ave neighs/atom = 135.31650
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -17496.169   -17496.169   -17648.973   -17648.973     295.6098     295.6098    44114.802    44114.802      144.575      144.575 
    3000   -17495.469   -17495.469    -17646.81    -17646.81    292.77988    292.77988    44116.673    44116.673    235.90424    235.90424 
Loop time of 434.329 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.647 hours/ns, 2.302 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    | 433.24     | 433.24     | 433.24     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1726     | 0.1726     | 0.1726     |   0.0 |  0.04
Output  | 0.0002153  | 0.0002153  | 0.0002153  |   0.0 |  0.00
Modify  | 0.80814    | 0.80814    | 0.80814    |   0.0 |  0.19
Other   |            | 0.1068     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6150.00 ave        6150 max        6150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541000.0 ave      541000 max      541000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541000
Ave neighs/atom = 135.25000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -17495.469   -17495.469    -17646.81    -17646.81    292.77988    292.77988    44116.673    44116.673    235.90424    235.90424 
    4000   -17493.172   -17493.172   -17646.043   -17646.043    295.73855    295.73855    44136.783    44136.783   -473.23164   -473.23164 
Loop time of 434.797 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.777 hours/ns, 2.300 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 433.74     | 433.74     | 433.74     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16929    | 0.16929    | 0.16929    |   0.0 |  0.04
Output  | 0.00028091 | 0.00028091 | 0.00028091 |   0.0 |  0.00
Modify  | 0.78593    | 0.78593    | 0.78593    |   0.0 |  0.18
Other   |            | 0.1049     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6113.00 ave        6113 max        6113 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541126.0 ave      541126 max      541126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541126
Ave neighs/atom = 135.28150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -17493.172   -17493.172   -17646.043   -17646.043    295.73855    295.73855    44136.783    44136.783   -473.23164   -473.23164 
    5000   -17497.998   -17497.998    -17650.24    -17650.24    294.52206    294.52206    44132.523    44132.523   -767.87942   -767.87942 
Loop time of 433.338 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.372 hours/ns, 2.308 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 432.26     | 432.26     | 432.26     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1708     | 0.1708     | 0.1708     |   0.0 |  0.04
Output  | 0.00018232 | 0.00018232 | 0.00018232 |   0.0 |  0.00
Modify  | 0.80237    | 0.80237    | 0.80237    |   0.0 |  0.19
Other   |            | 0.1064     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6142.00 ave        6142 max        6142 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541110.0 ave      541110 max      541110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541110
Ave neighs/atom = 135.27750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.295148062943, Press = 346.173160248603
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -17497.998   -17497.998    -17650.24    -17650.24    294.52206    294.52206    44132.523    44132.523   -767.87942   -767.87942 
    6000    -17492.32    -17492.32   -17644.702   -17644.702    294.79184    294.79184    44169.255    44169.255   -1740.6785   -1740.6785 
Loop time of 429.304 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 428.24     | 428.24     | 428.24     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16736    | 0.16736    | 0.16736    |   0.0 |  0.04
Output  | 0.00017911 | 0.00017911 | 0.00017911 |   0.0 |  0.00
Modify  | 0.7907     | 0.7907     | 0.7907     |   0.0 |  0.18
Other   |            | 0.1032     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6133.00 ave        6133 max        6133 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541126.0 ave      541126 max      541126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541126
Ave neighs/atom = 135.28150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.714115830436, Press = 21.3565123088513
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000    -17492.32    -17492.32   -17644.702   -17644.702    294.79184    294.79184    44169.255    44169.255   -1740.6785   -1740.6785 
    7000   -17498.285   -17498.285   -17652.738   -17652.738    298.79937    298.79937     44178.88     44178.88   -2789.7999   -2789.7999 
Loop time of 435.102 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.199 ns/day, 120.862 hours/ns, 2.298 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    | 434.01     | 434.01     | 434.01     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1706     | 0.1706     | 0.1706     |   0.0 |  0.04
Output  | 0.00022601 | 0.00022601 | 0.00022601 |   0.0 |  0.00
Modify  | 0.81895    | 0.81895    | 0.81895    |   0.0 |  0.19
Other   |            | 0.1053     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6159.00 ave        6159 max        6159 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      540896.0 ave      540896 max      540896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540896
Ave neighs/atom = 135.22400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.003679186476, Press = -12.9941405330018
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -17498.285   -17498.285   -17652.738   -17652.738    298.79937    298.79937     44178.88     44178.88   -2789.7999   -2789.7999 
    8000   -17494.277   -17494.277   -17649.014   -17649.014    299.34904    299.34904    44145.566    44145.566   -1130.3577   -1130.3577 
Loop time of 435.024 on 1 procs for 1000 steps with 4000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 433.91     | 433.91     | 433.91     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1706     | 0.1706     | 0.1706     |   0.0 |  0.04
Output  | 0.00018111 | 0.00018111 | 0.00018111 |   0.0 |  0.00
Modify  | 0.83458    | 0.83458    | 0.83458    |   0.0 |  0.19
Other   |            | 0.1071     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6079.00 ave        6079 max        6079 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      540720.0 ave      540720 max      540720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540720
Ave neighs/atom = 135.18000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.925991324895, Press = -11.7927504678851
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -17494.277   -17494.277   -17649.014   -17649.014    299.34904    299.34904    44145.566    44145.566   -1130.3577   -1130.3577 
    9000   -17498.257   -17498.257   -17647.393   -17647.393    288.51344    288.51344     44108.38     44108.38    509.43022    509.43022 
Loop time of 429.626 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.340 hours/ns, 2.328 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    | 428.54     | 428.54     | 428.54     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17003    | 0.17003    | 0.17003    |   0.0 |  0.04
Output  | 0.00017843 | 0.00017843 | 0.00017843 |   0.0 |  0.00
Modify  | 0.80736    | 0.80736    | 0.80736    |   0.0 |  0.19
Other   |            | 0.1046     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6161.00 ave        6161 max        6161 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      540876.0 ave      540876 max      540876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540876
Ave neighs/atom = 135.21900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.563292444283, Press = -3.10732650727816
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.371 | 5.371 | 5.371 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -17498.257   -17498.257   -17647.393   -17647.393    288.51344    288.51344     44108.38     44108.38    509.43022    509.43022 
   10000    -17496.59    -17496.59   -17647.732   -17647.732    292.39455    292.39455    44106.163    44106.163    610.49141    610.49141 
Loop time of 430.282 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.523 hours/ns, 2.324 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    | 429.19     | 429.19     | 429.19     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16794    | 0.16794    | 0.16794    |   0.0 |  0.04
Output  | 0.00017574 | 0.00017574 | 0.00017574 |   0.0 |  0.00
Modify  | 0.81609    | 0.81609    | 0.81609    |   0.0 |  0.19
Other   |            | 0.105      |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6058.00 ave        6058 max        6058 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541092.0 ave      541092 max      541092 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541092
Ave neighs/atom = 135.27300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.849036355188, Press = 1.28725172121813
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000    -17496.59    -17496.59   -17647.732   -17647.732    292.39455    292.39455    44106.163    44106.163    610.49141    610.49141 
   11000   -17490.219   -17490.219   -17644.804   -17644.804    299.05575    299.05575    44106.231    44106.231    944.31546    944.31546 
Loop time of 384.728 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.869 hours/ns, 2.599 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 383.78     | 383.78     | 383.78     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15697    | 0.15697    | 0.15697    |   0.0 |  0.04
Output  | 0.00018143 | 0.00018143 | 0.00018143 |   0.0 |  0.00
Modify  | 0.69816    | 0.69816    | 0.69816    |   0.0 |  0.18
Other   |            | 0.09596    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6196.00 ave        6196 max        6196 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541110.0 ave      541110 max      541110 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541110
Ave neighs/atom = 135.27750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.165074201611, Press = 4.48273766066796
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -17490.219   -17490.219   -17644.804   -17644.804    299.05575    299.05575    44106.231    44106.231    944.31546    944.31546 
   12000   -17497.809   -17497.809   -17646.554   -17646.554    287.75764    287.75764    44082.103    44082.103     1689.103     1689.103 
Loop time of 372.169 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.232 ns/day, 103.380 hours/ns, 2.687 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.26     | 371.26     | 371.26     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15103    | 0.15103    | 0.15103    |   0.0 |  0.04
Output  | 0.00018257 | 0.00018257 | 0.00018257 |   0.0 |  0.00
Modify  | 0.66295    | 0.66295    | 0.66295    |   0.0 |  0.18
Other   |            | 0.09298    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6109.00 ave        6109 max        6109 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541166.0 ave      541166 max      541166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541166
Ave neighs/atom = 135.29150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.333576537413, Press = 7.57669510809181
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -17497.809   -17497.809   -17646.554   -17646.554    287.75764    287.75764    44082.103    44082.103     1689.103     1689.103 
   13000    -17491.48    -17491.48    -17643.96    -17643.96    294.98218    294.98218    44079.358    44079.358    2180.9181    2180.9181 
Loop time of 371.605 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 103.224 hours/ns, 2.691 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 370.7      | 370.7      | 370.7      |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15106    | 0.15106    | 0.15106    |   0.0 |  0.04
Output  | 0.0001854  | 0.0001854  | 0.0001854  |   0.0 |  0.00
Modify  | 0.66202    | 0.66202    | 0.66202    |   0.0 |  0.18
Other   |            | 0.09372    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6137.00 ave        6137 max        6137 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541210.0 ave      541210 max      541210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541210
Ave neighs/atom = 135.30250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.479430060356, Press = 17.4782430653307
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000    -17491.48    -17491.48    -17643.96    -17643.96    294.98218    294.98218    44079.358    44079.358    2180.9181    2180.9181 
   14000   -17496.526   -17496.526   -17645.812   -17645.812    288.80463    288.80463    44131.506    44131.506   -348.05087   -348.05087 
Loop time of 372.456 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.232 ns/day, 103.460 hours/ns, 2.685 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.55     | 371.55     | 371.55     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15194    | 0.15194    | 0.15194    |   0.0 |  0.04
Output  | 0.00018077 | 0.00018077 | 0.00018077 |   0.0 |  0.00
Modify  | 0.66401    | 0.66401    | 0.66401    |   0.0 |  0.18
Other   |            | 0.09209    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6163.00 ave        6163 max        6163 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541210.0 ave      541210 max      541210 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541210
Ave neighs/atom = 135.30250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.555787434994, Press = 9.46230139241308
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -17496.526   -17496.526   -17645.812   -17645.812    288.80463    288.80463    44131.506    44131.506   -348.05087   -348.05087 
   15000   -17495.897   -17495.897   -17648.537   -17648.537    295.29261    295.29261     44147.99     44147.99    -1191.039    -1191.039 
Loop time of 372.221 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.232 ns/day, 103.395 hours/ns, 2.687 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.31     | 371.31     | 371.31     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15197    | 0.15197    | 0.15197    |   0.0 |  0.04
Output  | 0.0001796  | 0.0001796  | 0.0001796  |   0.0 |  0.00
Modify  | 0.66305    | 0.66305    | 0.66305    |   0.0 |  0.18
Other   |            | 0.09308    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6170.00 ave        6170 max        6170 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541070.0 ave      541070 max      541070 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541070
Ave neighs/atom = 135.26750
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.644457045911, Press = 4.96488508026445
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -17495.897   -17495.897   -17648.537   -17648.537    295.29261    295.29261     44147.99     44147.99    -1191.039    -1191.039 
   16000   -17494.982   -17494.982   -17649.499   -17649.499    298.92268    298.92268    44149.006    44149.006   -1300.6511   -1300.6511 
Loop time of 372.557 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.232 ns/day, 103.488 hours/ns, 2.684 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.65     | 371.65     | 371.65     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1517     | 0.1517     | 0.1517     |   0.0 |  0.04
Output  | 0.00021967 | 0.00021967 | 0.00021967 |   0.0 |  0.00
Modify  | 0.66286    | 0.66286    | 0.66286    |   0.0 |  0.18
Other   |            | 0.09233    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6123.00 ave        6123 max        6123 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      540878.0 ave      540878 max      540878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540878
Ave neighs/atom = 135.21950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.578145147063, Press = 3.37306018925368
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -17494.982   -17494.982   -17649.499   -17649.499    298.92268    298.92268    44149.006    44149.006   -1300.6511   -1300.6511 
   17000    -17495.53    -17495.53   -17646.199   -17646.199    291.48013    291.48013    44138.098    44138.098   -686.33107   -686.33107 
Loop time of 372.336 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.232 ns/day, 103.427 hours/ns, 2.686 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 371.43     | 371.43     | 371.43     |   0.0 | 99.76
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15195    | 0.15195    | 0.15195    |   0.0 |  0.04
Output  | 0.00022987 | 0.00022987 | 0.00022987 |   0.0 |  0.00
Modify  | 0.66231    | 0.66231    | 0.66231    |   0.0 |  0.18
Other   |            | 0.09287    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6151.00 ave        6151 max        6151 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      540904.0 ave      540904 max      540904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540904
Ave neighs/atom = 135.22600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.599355219753, Press = 1.26150628037008
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000    -17495.53    -17495.53   -17646.199   -17646.199    291.48013    291.48013    44138.098    44138.098   -686.33107   -686.33107 
   18000   -17496.106   -17496.106    -17646.49    -17646.49      290.927      290.927    44131.003    44131.003    -283.3177    -283.3177 
Loop time of 390.266 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.407 hours/ns, 2.562 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    | 389.3      | 389.3      | 389.3      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15947    | 0.15947    | 0.15947    |   0.0 |  0.04
Output  | 0.00017871 | 0.00017871 | 0.00017871 |   0.0 |  0.00
Modify  | 0.71104    | 0.71104    | 0.71104    |   0.0 |  0.18
Other   |            | 0.09645    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6171.00 ave        6171 max        6171 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541130.0 ave      541130 max      541130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541130
Ave neighs/atom = 135.28250
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.54160424678, Press = -0.74672522677064
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -17496.106   -17496.106    -17646.49    -17646.49      290.927      290.927    44131.003    44131.003    -283.3177    -283.3177 
   19000   -17498.977   -17498.977   -17647.767   -17647.767    287.84344    287.84344     44090.78     44090.78     1206.776     1206.776 
Loop time of 432.709 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.197 hours/ns, 2.311 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    | 431.58     | 431.58     | 431.58     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17285    | 0.17285    | 0.17285    |   0.0 |  0.04
Output  | 0.00028028 | 0.00028028 | 0.00028028 |   0.0 |  0.00
Modify  | 0.84284    | 0.84284    | 0.84284    |   0.0 |  0.19
Other   |            | 0.1084     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6086.00 ave        6086 max        6086 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      540996.0 ave      540996 max      540996 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540996
Ave neighs/atom = 135.24900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.556597268802, Press = -2.34712368488018
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -17498.977   -17498.977   -17647.767   -17647.767    287.84344    287.84344     44090.78     44090.78     1206.776     1206.776 
   20000   -17495.365   -17495.365   -17647.377   -17647.377    294.07697    294.07697    44076.552    44076.552    1881.0696    1881.0696 
Loop time of 422.23 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.286 hours/ns, 2.368 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 421.16     | 421.16     | 421.16     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16846    | 0.16846    | 0.16846    |   0.0 |  0.04
Output  | 0.00018012 | 0.00018012 | 0.00018012 |   0.0 |  0.00
Modify  | 0.79809    | 0.79809    | 0.79809    |   0.0 |  0.19
Other   |            | 0.1039     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6124.00 ave        6124 max        6124 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541024.0 ave      541024 max      541024 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541024
Ave neighs/atom = 135.25600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.509830791524, Press = 0.638664968398381
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -17495.365   -17495.365   -17647.377   -17647.377    294.07697    294.07697    44076.552    44076.552    1881.0696    1881.0696 
   21000   -17494.373   -17494.373   -17646.179   -17646.179    293.67839    293.67839    44090.259    44090.259    1402.7636    1402.7636 
Loop time of 432.452 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.126 hours/ns, 2.312 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    | 431.35     | 431.35     | 431.35     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16999    | 0.16999    | 0.16999    |   0.0 |  0.04
Output  | 0.00018056 | 0.00018056 | 0.00018056 |   0.0 |  0.00
Modify  | 0.82945    | 0.82945    | 0.82945    |   0.0 |  0.19
Other   |            | 0.1064     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6120.00 ave        6120 max        6120 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541312.0 ave      541312 max      541312 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541312
Ave neighs/atom = 135.32800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.501275292686, Press = 2.00855749198666
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -17494.373   -17494.373   -17646.179   -17646.179    293.67839    293.67839    44090.259    44090.259    1402.7636    1402.7636 
   22000   -17497.773   -17497.773   -17647.676   -17647.676    289.99659    289.99659    44107.071    44107.071    558.70678    558.70678 
Loop time of 406.505 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.213 ns/day, 112.918 hours/ns, 2.460 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    | 405.48     | 405.48     | 405.48     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16489    | 0.16489    | 0.16489    |   0.0 |  0.04
Output  | 0.00018022 | 0.00018022 | 0.00018022 |   0.0 |  0.00
Modify  | 0.76208    | 0.76208    | 0.76208    |   0.0 |  0.19
Other   |            | 0.1017     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6145.00 ave        6145 max        6145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541380.0 ave      541380 max      541380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541380
Ave neighs/atom = 135.34500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.43503358996, Press = 1.99652680161328
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -17497.773   -17497.773   -17647.676   -17647.676    289.99659    289.99659    44107.071    44107.071    558.70678    558.70678 
   23000   -17496.102   -17496.102   -17646.833   -17646.833    291.59885    291.59885    44115.401    44115.401    314.37287    314.37287 
Loop time of 421.234 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.009 hours/ns, 2.374 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    | 420.17     | 420.17     | 420.17     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16786    | 0.16786    | 0.16786    |   0.0 |  0.04
Output  | 0.00017857 | 0.00017857 | 0.00017857 |   0.0 |  0.00
Modify  | 0.78843    | 0.78843    | 0.78843    |   0.0 |  0.19
Other   |            | 0.1036     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6106.00 ave        6106 max        6106 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541194.0 ave      541194 max      541194 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541194
Ave neighs/atom = 135.29850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.360128598986, Press = 1.88048769164194
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -17496.102   -17496.102   -17646.833   -17646.833    291.59885    291.59885    44115.401    44115.401    314.37287    314.37287 
   24000   -17498.279   -17498.279   -17645.483   -17645.483    284.77688    284.77688    44113.401    44113.401    403.54068    403.54068 
Loop time of 380.061 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.572 hours/ns, 2.631 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    | 379.12     | 379.12     | 379.12     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15621    | 0.15621    | 0.15621    |   0.0 |  0.04
Output  | 0.0001804  | 0.0001804  | 0.0001804  |   0.0 |  0.00
Modify  | 0.69091    | 0.69091    | 0.69091    |   0.0 |  0.18
Other   |            | 0.0977     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6157.00 ave        6157 max        6157 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541142.0 ave      541142 max      541142 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541142
Ave neighs/atom = 135.28550
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.272816673154, Press = 1.63473758625138
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -17498.279   -17498.279   -17645.483   -17645.483    284.77688    284.77688    44113.401    44113.401    403.54068    403.54068 
   25000   -17493.574   -17493.574   -17646.868   -17646.868    296.55737    296.55737    44124.917    44124.917   -25.194512   -25.194512 
Loop time of 389.16 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.100 hours/ns, 2.570 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    | 388.2      | 388.2      | 388.2      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15629    | 0.15629    | 0.15629    |   0.0 |  0.04
Output  | 0.00018623 | 0.00018623 | 0.00018623 |   0.0 |  0.00
Modify  | 0.70292    | 0.70292    | 0.70292    |   0.0 |  0.18
Other   |            | 0.097      |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6131.00 ave        6131 max        6131 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541174.0 ave      541174 max      541174 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541174
Ave neighs/atom = 135.29350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.208121839195, Press = 1.18329881814499
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -17493.574   -17493.574   -17646.868   -17646.868    296.55737    296.55737    44124.917    44124.917   -25.194512   -25.194512 
   26000   -17496.154   -17496.154   -17645.355   -17645.355    288.63935    288.63935    44123.799    44123.799    49.550732    49.550732 
Loop time of 425.981 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.203 ns/day, 118.328 hours/ns, 2.348 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    | 424.9      | 424.9      | 424.9      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17127    | 0.17127    | 0.17127    |   0.0 |  0.04
Output  | 0.00017795 | 0.00017795 | 0.00017795 |   0.0 |  0.00
Modify  | 0.80191    | 0.80191    | 0.80191    |   0.0 |  0.19
Other   |            | 0.1046     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6163.00 ave        6163 max        6163 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541192.0 ave      541192 max      541192 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541192
Ave neighs/atom = 135.29800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.159994818827, Press = 1.14961003105371
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -17496.154   -17496.154   -17645.355   -17645.355    288.63935    288.63935    44123.799    44123.799    49.550732    49.550732 
   27000   -17495.221   -17495.221   -17648.269   -17648.269    296.08191    296.08191    44123.172    44123.172   -161.02679   -161.02679 
Loop time of 428.219 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.202 ns/day, 118.950 hours/ns, 2.335 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    | 427.14     | 427.14     | 427.14     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17036    | 0.17036    | 0.17036    |   0.0 |  0.04
Output  | 0.00018038 | 0.00018038 | 0.00018038 |   0.0 |  0.00
Modify  | 0.80106    | 0.80106    | 0.80106    |   0.0 |  0.19
Other   |            | 0.1053     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6148.00 ave        6148 max        6148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541166.0 ave      541166 max      541166 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541166
Ave neighs/atom = 135.29150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.197938522018, Press = 0.9972985251959
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -17495.221   -17495.221   -17648.269   -17648.269    296.08191    296.08191    44123.172    44123.172   -161.02679   -161.02679 
   28000   -17489.174   -17489.174   -17643.844   -17643.844    299.21981    299.21981    44141.889    44141.889   -404.17489   -404.17489 
Loop time of 418.026 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.207 ns/day, 116.118 hours/ns, 2.392 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 416.96     | 416.96     | 416.96     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17069    | 0.17069    | 0.17069    |   0.0 |  0.04
Output  | 0.00018169 | 0.00018169 | 0.00018169 |   0.0 |  0.00
Modify  | 0.78895    | 0.78895    | 0.78895    |   0.0 |  0.19
Other   |            | 0.1024     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6175.00 ave        6175 max        6175 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541042.0 ave      541042 max      541042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541042
Ave neighs/atom = 135.26050
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.235602439021, Press = 1.16030423954855
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -17489.174   -17489.174   -17643.844   -17643.844    299.21981    299.21981    44141.889    44141.889   -404.17489   -404.17489 
   29000   -17496.404   -17496.404   -17646.517   -17646.517    290.40425    290.40425    44137.535    44137.535   -553.68869   -553.68869 
Loop time of 429.825 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.201 ns/day, 119.396 hours/ns, 2.327 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    | 428.72     | 428.72     | 428.72     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17181    | 0.17181    | 0.17181    |   0.0 |  0.04
Output  | 0.00022206 | 0.00022206 | 0.00022206 |   0.0 |  0.00
Modify  | 0.82423    | 0.82423    | 0.82423    |   0.0 |  0.19
Other   |            | 0.1056     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6102.00 ave        6102 max        6102 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541072.0 ave      541072 max      541072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541072
Ave neighs/atom = 135.26800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.271562950265, Press = 0.658711282689735
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -17496.404   -17496.404   -17646.517   -17646.517    290.40425    290.40425    44137.535    44137.535   -553.68869   -553.68869 
   30000   -17489.702   -17489.702   -17643.247   -17643.247    297.04226    297.04226    44148.976    44148.976   -678.56972   -678.56972 
Loop time of 407.758 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.212 ns/day, 113.266 hours/ns, 2.452 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    | 406.71     | 406.71     | 406.71     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16565    | 0.16565    | 0.16565    |   0.0 |  0.04
Output  | 0.00018058 | 0.00018058 | 0.00018058 |   0.0 |  0.00
Modify  | 0.77537    | 0.77537    | 0.77537    |   0.0 |  0.19
Other   |            | 0.1033     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6116.00 ave        6116 max        6116 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      540896.0 ave      540896 max      540896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540896
Ave neighs/atom = 135.22400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.344538421852, Press = -0.354983504647402
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -17489.702   -17489.702   -17643.247   -17643.247    297.04226    297.04226    44148.976    44148.976   -678.56972   -678.56972 
   31000   -17495.577   -17495.577   -17645.311   -17645.311    289.66961    289.66961    44120.047    44120.047    217.94652    217.94652 
Loop time of 431.616 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 119.893 hours/ns, 2.317 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 430.52     | 430.52     | 430.52     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17363    | 0.17363    | 0.17363    |   0.0 |  0.04
Output  | 0.00018046 | 0.00018046 | 0.00018046 |   0.0 |  0.00
Modify  | 0.82113    | 0.82113    | 0.82113    |   0.0 |  0.19
Other   |            | 0.1051     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6101.00 ave        6101 max        6101 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      540974.0 ave      540974 max      540974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540974
Ave neighs/atom = 135.24350
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.367864978945, Press = -0.658189015163167
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -17495.577   -17495.577   -17645.311   -17645.311    289.66961    289.66961    44120.047    44120.047    217.94652    217.94652 
   32000    -17496.14    -17496.14   -17647.572   -17647.572     292.9557     292.9557    44092.819    44092.819    1176.9545    1176.9545 
Loop time of 375.599 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.333 hours/ns, 2.662 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 374.67     | 374.67     | 374.67     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15437    | 0.15437    | 0.15437    |   0.0 |  0.04
Output  | 0.00018035 | 0.00018035 | 0.00018035 |   0.0 |  0.00
Modify  | 0.67597    | 0.67597    | 0.67597    |   0.0 |  0.18
Other   |            | 0.0952     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6188.00 ave        6188 max        6188 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541218.0 ave      541218 max      541218 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541218
Ave neighs/atom = 135.30450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.371339528567, Press = -0.515228294437598
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000    -17496.14    -17496.14   -17647.572   -17647.572     292.9557     292.9557    44092.819    44092.819    1176.9545    1176.9545 
   33000   -17492.249   -17492.249   -17644.903   -17644.903    295.31843    295.31843    44075.246    44075.246    2154.3683    2154.3683 
Loop time of 373.37 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.714 hours/ns, 2.678 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    | 372.45     | 372.45     | 372.45     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15734    | 0.15734    | 0.15734    |   0.0 |  0.04
Output  | 0.00018125 | 0.00018125 | 0.00018125 |   0.0 |  0.00
Modify  | 0.6694     | 0.6694     | 0.6694     |   0.0 |  0.18
Other   |            | 0.09542    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6187.00 ave        6187 max        6187 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541274.0 ave      541274 max      541274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541274
Ave neighs/atom = 135.31850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.351197482704, Press = 0.037475559423573
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -17492.249   -17492.249   -17644.903   -17644.903    295.31843    295.31843    44075.246    44075.246    2154.3683    2154.3683 
   34000   -17497.524   -17497.524   -17646.302   -17646.302    287.81987    287.81987    44070.305    44070.305     2164.024     2164.024 
Loop time of 394.634 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.219 ns/day, 109.620 hours/ns, 2.534 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 393.65     | 393.65     | 393.65     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16256    | 0.16256    | 0.16256    |   0.0 |  0.04
Output  | 0.00018012 | 0.00018012 | 0.00018012 |   0.0 |  0.00
Modify  | 0.72353    | 0.72353    | 0.72353    |   0.0 |  0.18
Other   |            | 0.09891    |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6179.00 ave        6179 max        6179 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541354.0 ave      541354 max      541354 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541354
Ave neighs/atom = 135.33850
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.365628243132, Press = 1.263410190554
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -17497.524   -17497.524   -17646.302   -17646.302    287.81987    287.81987    44070.305    44070.305     2164.024     2164.024 
   35000   -17489.882   -17489.882    -17644.59    -17644.59    299.29309    299.29309    44114.854    44114.854     676.3523     676.3523 
Loop time of 401.402 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.215 ns/day, 111.500 hours/ns, 2.491 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    | 400.39     | 400.39     | 400.39     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16309    | 0.16309    | 0.16309    |   0.0 |  0.04
Output  | 0.00023412 | 0.00023412 | 0.00023412 |   0.0 |  0.00
Modify  | 0.74203    | 0.74203    | 0.74203    |   0.0 |  0.18
Other   |            | 0.1016     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6190.00 ave        6190 max        6190 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541364.0 ave      541364 max      541364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541364
Ave neighs/atom = 135.34100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.382051863782, Press = 1.46745083581693
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -17489.882   -17489.882    -17644.59    -17644.59    299.29309    299.29309    44114.854    44114.854     676.3523     676.3523 
   36000   -17496.345   -17496.345   -17647.456   -17647.456    292.33584    292.33584    44110.891    44110.891    417.79956    417.79956 
Loop time of 422.464 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.205 ns/day, 117.351 hours/ns, 2.367 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    | 421.4      | 421.4      | 421.4      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16839    | 0.16839    | 0.16839    |   0.0 |  0.04
Output  | 0.00018175 | 0.00018175 | 0.00018175 |   0.0 |  0.00
Modify  | 0.79292    | 0.79292    | 0.79292    |   0.0 |  0.19
Other   |            | 0.103      |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6136.00 ave        6136 max        6136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541118.0 ave      541118 max      541118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541118
Ave neighs/atom = 135.27950
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.421607214103, Press = 1.41607647127789
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -17496.345   -17496.345   -17647.456   -17647.456    292.33584    292.33584    44110.891    44110.891    417.79956    417.79956 
   37000   -17493.395   -17493.395   -17646.832   -17646.832    296.83439    296.83439    44132.618    44132.618   -427.12098   -427.12098 
Loop time of 396.945 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.218 ns/day, 110.263 hours/ns, 2.519 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 395.95     | 395.95     | 395.95     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16145    | 0.16145    | 0.16145    |   0.0 |  0.04
Output  | 0.00017745 | 0.00017745 | 0.00017745 |   0.0 |  0.00
Modify  | 0.73039    | 0.73039    | 0.73039    |   0.0 |  0.18
Other   |            | 0.09895    |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6120.00 ave        6120 max        6120 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541156.0 ave      541156 max      541156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541156
Ave neighs/atom = 135.28900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.398540643307, Press = 1.48728847392086
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -17493.395   -17493.395   -17646.832   -17646.832    296.83439    296.83439    44132.618    44132.618   -427.12098   -427.12098 
   38000   -17493.236   -17493.236   -17645.838   -17645.838    295.21837    295.21837    44161.169    44161.169   -1491.5554   -1491.5554 
Loop time of 432.064 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.200 ns/day, 120.018 hours/ns, 2.314 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    | 430.95     | 430.95     | 430.95     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17418    | 0.17418    | 0.17418    |   0.0 |  0.04
Output  | 0.0002789  | 0.0002789  | 0.0002789  |   0.0 |  0.00
Modify  | 0.83322    | 0.83322    | 0.83322    |   0.0 |  0.19
Other   |            | 0.1068     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6171.00 ave        6171 max        6171 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      541086.0 ave      541086 max      541086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 541086
Ave neighs/atom = 135.27150
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.388587812704, Press = 1.46823722217639
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -17493.236   -17493.236   -17645.838   -17645.838    295.21837    295.21837    44161.169    44161.169   -1491.5554   -1491.5554 
   39000   -17497.886   -17497.886   -17647.657   -17647.657    289.74185    289.74185    44200.252    44200.252   -3342.2323   -3342.2323 
Loop time of 423.536 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.204 ns/day, 117.649 hours/ns, 2.361 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    | 422.46     | 422.46     | 422.46     |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1722     | 0.1722     | 0.1722     |   0.0 |  0.04
Output  | 0.00017915 | 0.00017915 | 0.00017915 |   0.0 |  0.00
Modify  | 0.79911    | 0.79911    | 0.79911    |   0.0 |  0.19
Other   |            | 0.1048     |            |       |  0.02

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6157.00 ave        6157 max        6157 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      540858.0 ave      540858 max      540858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540858
Ave neighs/atom = 135.21450
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.320806998404, Press = 0.533953347346516
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -17497.886   -17497.886   -17647.657   -17647.657    289.74185    289.74185    44200.252    44200.252   -3342.2323   -3342.2323 
   40000   -17495.009   -17495.009   -17644.291   -17644.291    288.79639    288.79639    44168.452    44168.452   -1652.2477   -1652.2477 
Loop time of 389.98 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.328 hours/ns, 2.564 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    | 389        | 389        | 389        |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15919    | 0.15919    | 0.15919    |   0.0 |  0.04
Output  | 0.00022873 | 0.00022873 | 0.00022873 |   0.0 |  0.00
Modify  | 0.7231     | 0.7231     | 0.7231     |   0.0 |  0.19
Other   |            | 0.1008     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6115.00 ave        6115 max        6115 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      540716.0 ave      540716 max      540716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540716
Ave neighs/atom = 135.17900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.308444312238, Press = -0.268626903082964
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7
  ghost atom cutoff = 7
  binsize = 3.5, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 5.372 | 5.372 | 5.372 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -17495.009   -17495.009   -17644.291   -17644.291    288.79639    288.79639    44168.452    44168.452   -1652.2477   -1652.2477 
   41000   -17490.687   -17490.687   -17642.653   -17642.653    293.98871    293.98871    44148.226    44148.226    -660.7862    -660.7862 
Loop time of 415.86 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.208 ns/day, 115.517 hours/ns, 2.405 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    | 414.8      | 414.8      | 414.8      |   0.0 | 99.75
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16785    | 0.16785    | 0.16785    |   0.0 |  0.04
Output  | 0.00018147 | 0.00018147 | 0.00018147 |   0.0 |  0.00
Modify  | 0.78536    | 0.78536    | 0.78536    |   0.0 |  0.19
Other   |            | 0.1051     |            |       |  0.03

Nlocal:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        6144.00 ave        6144 max        6144 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      540888.0 ave      540888 max      540888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 540888
Ave neighs/atom = 135.22200
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
44123.2567228552

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0