# 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 2.86696694791317*${_u_distance}
variable latticeconst_converted equal 2.86696694791317*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.86696694791317
Lattice spacing in x,y,z = 2.8669669 2.8669669 2.8669669
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 (28.669669 28.669669 28.669669)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (28.669669 28.669669 28.669669)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Fe

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

kim interactions Fe
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_BelandTammMu_2017_FeNiCr__MO_715003088863_000
pair_coeff * * Fe
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 55.845

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 23565.0333387724 Angstroms^3

# set the time step to 0.001 picoseconds
variable timestep_converted equal 0.001*${_u_time}
variable timestep_converted equal 0.001*1
timestep ${timestep_converted}
timestep 0.001

variable temp_converted equal 273.15*${_u_temperature}
variable temp_converted equal 273.15*1
variable Tdamp_converted equal 0.1*${_u_time}
variable Tdamp_converted equal 0.1*1
variable press_converted equal 0.0*${_u_pressure}
variable press_converted equal 0.0*1
variable Pdamp_converted equal 1*${_u_time}
variable Pdamp_converted equal 1*1

# create initial velocities consistent with the chosen temperature
velocity      all create ${temp_converted} 17 mom yes rot yes
velocity      all create 273.15 17 mom yes rot yes

# set NPT ensemble for all atoms
fix           ensemble all npt temp ${temp_converted} ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 1

# compute the time averages of pressure, temperature, and volume, respectively
# ignore the first 5000 timesteps
variable      etotal_metal equal etotal/${_u_energy}
variable      etotal_metal equal etotal/1
variable      pe_metal equal pe/${_u_energy}
variable      pe_metal equal pe/1
variable      T_metal equal temp/${_u_temperature}
variable      T_metal equal temp/1
variable      V_metal equal vol/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*${_u_distance}*${_u_distance})
variable      V_metal equal vol/(1*1*${_u_distance})
variable      V_metal equal vol/(1*1*1)
variable      P_metal equal press/${_u_pressure}
variable      P_metal equal press/1
fix           avgmyTemp  all ave/time 5 20 100 v_T_metal  ave running start 5000
fix           avgmyPress all ave/time 5 20 100 v_P_metal ave running start 5000
fix           avgmyVol   all ave/time 5 20 100 v_V_metal   ave running start 5000

# extract fix quantities into variables so they can be used in if-else logic later.
variable      T equal f_avgmyTemp
variable      P equal f_avgmyPress
variable      V equal f_avgmyVol

# set error bounds for temperature and pressure in original metal units (K and bar)
variable      T_low equal  "273.15 - 0.2"
variable      T_up  equal  "273.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

# print to logfile every 1000 timesteps
thermo_style  custom step etotal v_etotal_metal pe v_pe_metal               temp v_T_metal vol v_V_metal press v_P_metal
thermo        1000

# Run a simulation for at most 2000*1000 timesteps. At each 1000th time step, check
# whether the temperature and pressure have converged. If yes, break.
label top
variable a loop 2000
run 1000

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

Your simulation uses code contributions which should be cited:

- OpenKIM: https://doi.org/10.1007/s11837-011-0102-6

@Article{tadmor:elliott:2011,
 author = {E. B. Tadmor and R. S. Elliott and J. P. Sethna and R. E. Miller and C. A. Becker},
 title = {The potential of atomistic simulations and the {K}nowledgebase of {I}nteratomic {M}odels},
 journal = {{JOM}},
 year =    2011,
 volume =  63,
 number =  17,
 pages =   {17},
 doi =     {10.1007/s11837-011-0102-6}
}

- OpenKIM potential: https://openkim.org/cite/MO_715003088863_000#item-citation

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 7.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0    -7938.493    -7938.493   -8009.0725   -8009.0725       273.15       273.15    23565.033    23565.033    3199.0996    3199.0996 
    1000   -7999.7516   -7999.7516    -8071.486    -8071.486     277.6197     277.6197    21560.453    21560.453   -637.27481   -637.27481 
Loop time of 31.8325 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.714 ns/day, 8.842 hours/ns, 31.414 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    | 31.133     | 31.133     | 31.133     |   0.0 | 97.80
Neigh   | 0.14826    | 0.14826    | 0.14826    |   0.0 |  0.47
Comm    | 0.12974    | 0.12974    | 0.12974    |   0.0 |  0.41
Output  | 0.00019156 | 0.00019156 | 0.00019156 |   0.0 |  0.00
Modify  | 0.35632    | 0.35632    | 0.35632    |   0.0 |  1.12
Other   |            | 0.06543    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5471.00 ave        5471 max        5471 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:      333526.0 ave      333526 max      333526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333526
Ave neighs/atom = 166.76300
Neighbor list builds = 3
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -7999.7516   -7999.7516    -8071.486    -8071.486     277.6197     277.6197    21560.453    21560.453   -637.27481   -637.27481 
    2000   -8028.7376   -8028.7376   -8098.7307   -8098.7307    270.88027    270.88027    21579.029    21579.029       116.69       116.69 
Loop time of 32.0088 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.699 ns/day, 8.891 hours/ns, 31.241 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    | 31.369     | 31.369     | 31.369     |   0.0 | 98.00
Neigh   | 0.099306   | 0.099306   | 0.099306   |   0.0 |  0.31
Comm    | 0.12641    | 0.12641    | 0.12641    |   0.0 |  0.39
Output  | 0.00018979 | 0.00018979 | 0.00018979 |   0.0 |  0.00
Modify  | 0.34981    | 0.34981    | 0.34981    |   0.0 |  1.09
Other   |            | 0.06428    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5444.00 ave        5444 max        5444 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:      332814.0 ave      332814 max      332814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332814
Ave neighs/atom = 166.40700
Neighbor list builds = 2
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -8028.7376   -8028.7376   -8098.7307   -8098.7307    270.88027    270.88027    21579.029    21579.029       116.69       116.69 
    3000   -8034.3062   -8034.3062   -8105.6993   -8105.6993    276.29891    276.29891    21584.043    21584.043   -2543.3803   -2543.3803 
Loop time of 32.0051 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.700 ns/day, 8.890 hours/ns, 31.245 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.418     | 31.418     | 31.418     |   0.0 | 98.17
Neigh   | 0.047076   | 0.047076   | 0.047076   |   0.0 |  0.15
Comm    | 0.12468    | 0.12468    | 0.12468    |   0.0 |  0.39
Output  | 0.0002304  | 0.0002304  | 0.0002304  |   0.0 |  0.00
Modify  | 0.34997    | 0.34997    | 0.34997    |   0.0 |  1.09
Other   |            | 0.06473    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5442.00 ave        5442 max        5442 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:      332504.0 ave      332504 max      332504 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332504
Ave neighs/atom = 166.25200
Neighbor list builds = 1
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -8034.3062   -8034.3062   -8105.6993   -8105.6993    276.29891    276.29891    21584.043    21584.043   -2543.3803   -2543.3803 
    4000   -8033.9622   -8033.9622   -8105.2695   -8105.2695    275.96643    275.96643     21552.44     21552.44    546.30499    546.30499 
Loop time of 32.8708 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.628 ns/day, 9.131 hours/ns, 30.422 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    | 32.318     | 32.318     | 32.318     |   0.0 | 98.32
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12681    | 0.12681    | 0.12681    |   0.0 |  0.39
Output  | 0.00019391 | 0.00019391 | 0.00019391 |   0.0 |  0.00
Modify  | 0.36101    | 0.36101    | 0.36101    |   0.0 |  1.10
Other   |            | 0.06507    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5417.00 ave        5417 max        5417 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:      332736.0 ave      332736 max      332736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332736
Ave neighs/atom = 166.36800
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -8033.9622   -8033.9622   -8105.2695   -8105.2695    275.96643    275.96643     21552.44     21552.44    546.30499    546.30499 
    5000   -8036.5034   -8036.5034   -8107.0438   -8107.0438    272.99862    272.99862    21527.861    21527.861    1954.5997    1954.5997 
Loop time of 32.0046 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.700 ns/day, 8.890 hours/ns, 31.245 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 31.461     | 31.461     | 31.461     |   0.0 | 98.30
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12471    | 0.12471    | 0.12471    |   0.0 |  0.39
Output  | 0.00015031 | 0.00015031 | 0.00015031 |   0.0 |  0.00
Modify  | 0.35385    | 0.35385    | 0.35385    |   0.0 |  1.11
Other   |            | 0.06479    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5414.00 ave        5414 max        5414 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:      333098.0 ave      333098 max      333098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333098
Ave neighs/atom = 166.54900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 270.866171090203, Press = -1528.47270663145
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -8036.5034   -8036.5034   -8107.0438   -8107.0438    272.99862    272.99862    21527.861    21527.861    1954.5997    1954.5997 
    6000    -8032.538    -8032.538   -8104.3391   -8104.3391    277.87796    277.87796    21544.108    21544.108    1466.3445    1466.3445 
Loop time of 32.9298 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.624 ns/day, 9.147 hours/ns, 30.368 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    | 32.357     | 32.357     | 32.357     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12721    | 0.12721    | 0.12721    |   0.0 |  0.39
Output  | 0.00015163 | 0.00015163 | 0.00015163 |   0.0 |  0.00
Modify  | 0.3798     | 0.3798     | 0.3798     |   0.0 |  1.15
Other   |            | 0.06543    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5433.00 ave        5433 max        5433 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:      333462.0 ave      333462 max      333462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333462
Ave neighs/atom = 166.73100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.911034742686, Press = -91.5239485169288
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000    -8032.538    -8032.538   -8104.3391   -8104.3391    277.87796    277.87796    21544.108    21544.108    1466.3445    1466.3445 
    7000   -8035.1052   -8035.1052   -8104.5465   -8104.5465    268.74484    268.74484    21555.387    21555.387   -38.514065   -38.514065 
Loop time of 32.8199 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.633 ns/day, 9.117 hours/ns, 30.469 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    | 32.248     | 32.248     | 32.248     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12765    | 0.12765    | 0.12765    |   0.0 |  0.39
Output  | 0.0001527  | 0.0001527  | 0.0001527  |   0.0 |  0.00
Modify  | 0.37939    | 0.37939    | 0.37939    |   0.0 |  1.16
Other   |            | 0.06509    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5424.00 ave        5424 max        5424 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:      333200.0 ave      333200 max      333200 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333200
Ave neighs/atom = 166.60000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.700129275132, Press = -57.109181937788
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -8035.1052   -8035.1052   -8104.5465   -8104.5465    268.74484    268.74484    21555.387    21555.387   -38.514065   -38.514065 
    8000    -8035.455    -8035.455   -8106.7689   -8106.7689    275.99226    275.99226    21534.831    21534.831    68.127346    68.127346 
Loop time of 32.5999 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.650 ns/day, 9.056 hours/ns, 30.675 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    | 32.031     | 32.031     | 32.031     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12646    | 0.12646    | 0.12646    |   0.0 |  0.39
Output  | 0.0001512  | 0.0001512  | 0.0001512  |   0.0 |  0.00
Modify  | 0.37691    | 0.37691    | 0.37691    |   0.0 |  1.16
Other   |            | 0.06539    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5424.00 ave        5424 max        5424 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:      332992.0 ave      332992 max      332992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332992
Ave neighs/atom = 166.49600
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 = 274.153793471522, Press = -18.394845035137
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000    -8035.455    -8035.455   -8106.7689   -8106.7689    275.99226    275.99226    21534.831    21534.831    68.127346    68.127346 
    9000   -8034.3013   -8034.3013   -8103.5538   -8103.5538     268.0144     268.0144    21582.975    21582.975   -565.51042   -565.51042 
Loop time of 31.9966 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.700 ns/day, 8.888 hours/ns, 31.253 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    | 31.436     | 31.436     | 31.436     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12557    | 0.12557    | 0.12557    |   0.0 |  0.39
Output  | 0.00015061 | 0.00015061 | 0.00015061 |   0.0 |  0.00
Modify  | 0.36931    | 0.36931    | 0.36931    |   0.0 |  1.15
Other   |            | 0.06587    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5429.00 ave        5429 max        5429 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:      332944.0 ave      332944 max      332944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332944
Ave neighs/atom = 166.47200
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 = 274.235454954589, Press = -33.9827732962136
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -8034.3013   -8034.3013   -8103.5538   -8103.5538     268.0144     268.0144    21582.975    21582.975   -565.51042   -565.51042 
   10000   -8037.4075   -8037.4075   -8108.7019   -8108.7019    275.91673    275.91673     21572.51     21572.51   -2081.8603   -2081.8603 
Loop time of 33.2763 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.596 ns/day, 9.243 hours/ns, 30.051 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    | 32.7       | 32.7       | 32.7       |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12787    | 0.12787    | 0.12787    |   0.0 |  0.38
Output  | 0.00019338 | 0.00019338 | 0.00019338 |   0.0 |  0.00
Modify  | 0.38306    | 0.38306    | 0.38306    |   0.0 |  1.15
Other   |            | 0.06553    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5411.00 ave        5411 max        5411 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:      332496.0 ave      332496 max      332496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332496
Ave neighs/atom = 166.24800
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 = 274.416992379065, Press = -9.93872187278706
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -8037.4075   -8037.4075   -8108.7019   -8108.7019    275.91673    275.91673     21572.51     21572.51   -2081.8603   -2081.8603 
   11000   -8032.9276   -8032.9276   -8106.3699   -8106.3699    284.22931    284.22931    21538.378    21538.378    1718.2826    1718.2826 
Loop time of 33.511 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.578 ns/day, 9.309 hours/ns, 29.841 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    | 32.928     | 32.928     | 32.928     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12973    | 0.12973    | 0.12973    |   0.0 |  0.39
Output  | 0.0002577  | 0.0002577  | 0.0002577  |   0.0 |  0.00
Modify  | 0.38721    | 0.38721    | 0.38721    |   0.0 |  1.16
Other   |            | 0.0658     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5438.00 ave        5438 max        5438 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:      332582.0 ave      332582 max      332582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332582
Ave neighs/atom = 166.29100
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 = 274.189074357791, Press = -22.6284370795325
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -8032.9276   -8032.9276   -8106.3699   -8106.3699    284.22931    284.22931    21538.378    21538.378    1718.2826    1718.2826 
   12000   -8036.7175   -8036.7175   -8106.4548   -8106.4548    269.89058    269.89058    21571.449    21571.449    -470.7994    -470.7994 
Loop time of 32.7463 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.638 ns/day, 9.096 hours/ns, 30.538 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    | 32.177     | 32.177     | 32.177     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12665    | 0.12665    | 0.12665    |   0.0 |  0.39
Output  | 0.00015476 | 0.00015476 | 0.00015476 |   0.0 |  0.00
Modify  | 0.37833    | 0.37833    | 0.37833    |   0.0 |  1.16
Other   |            | 0.06456    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5417.00 ave        5417 max        5417 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:      333076.0 ave      333076 max      333076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333076
Ave neighs/atom = 166.53800
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 = 274.294773357339, Press = -14.41703042947
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -8036.7175   -8036.7175   -8106.4548   -8106.4548    269.89058    269.89058    21571.449    21571.449    -470.7994    -470.7994 
   13000   -8034.2958   -8034.2958   -8106.4098   -8106.4098    279.08847    279.08847    21583.525    21583.525   -1924.6856   -1924.6856 
Loop time of 32.7768 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.636 ns/day, 9.105 hours/ns, 30.509 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    | 32.2       | 32.2       | 32.2       |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1277     | 0.1277     | 0.1277     |   0.0 |  0.39
Output  | 0.0001505  | 0.0001505  | 0.0001505  |   0.0 |  0.00
Modify  | 0.38297    | 0.38297    | 0.38297    |   0.0 |  1.17
Other   |            | 0.06555    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5436.00 ave        5436 max        5436 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:      332698.0 ave      332698 max      332698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332698
Ave neighs/atom = 166.34900
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 = 274.351277598489, Press = -17.1331290042517
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -8034.2958   -8034.2958   -8106.4098   -8106.4098    279.08847    279.08847    21583.525    21583.525   -1924.6856   -1924.6856 
   14000   -8035.8015   -8035.8015   -8106.6082   -8106.6082    274.02914    274.02914    21585.204    21585.204   -2063.8773   -2063.8773 
Loop time of 32.4192 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.665 ns/day, 9.005 hours/ns, 30.846 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    | 31.852     | 31.852     | 31.852     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12599    | 0.12599    | 0.12599    |   0.0 |  0.39
Output  | 0.00015256 | 0.00015256 | 0.00015256 |   0.0 |  0.00
Modify  | 0.37506    | 0.37506    | 0.37506    |   0.0 |  1.16
Other   |            | 0.06561    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5433.00 ave        5433 max        5433 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:      332612.0 ave      332612 max      332612 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332612
Ave neighs/atom = 166.30600
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 = 274.172621568067, Press = -8.72722420702102
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -8035.8015   -8035.8015   -8106.6082   -8106.6082    274.02914    274.02914    21585.204    21585.204   -2063.8773   -2063.8773 
   15000   -8037.8739   -8037.8739   -8106.1979   -8106.1979    264.42109    264.42109    21538.488    21538.488    1755.3273    1755.3273 
Loop time of 32.5547 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.654 ns/day, 9.043 hours/ns, 30.718 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    | 31.987     | 31.987     | 31.987     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12669    | 0.12669    | 0.12669    |   0.0 |  0.39
Output  | 0.00014771 | 0.00014771 | 0.00014771 |   0.0 |  0.00
Modify  | 0.37601    | 0.37601    | 0.37601    |   0.0 |  1.16
Other   |            | 0.06497    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5415.00 ave        5415 max        5415 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:      332510.0 ave      332510 max      332510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332510
Ave neighs/atom = 166.25500
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 = 274.10767485104, Press = -8.86788695460314
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -8037.8739   -8037.8739   -8106.1979   -8106.1979    264.42109    264.42109    21538.488    21538.488    1755.3273    1755.3273 
   16000   -8036.1137   -8036.1137   -8105.9527   -8105.9527    270.28421    270.28421    21583.312    21583.312   -1224.3593   -1224.3593 
Loop time of 33.9409 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.546 ns/day, 9.428 hours/ns, 29.463 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    | 33.353     | 33.353     | 33.353     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13002    | 0.13002    | 0.13002    |   0.0 |  0.38
Output  | 0.00015345 | 0.00015345 | 0.00015345 |   0.0 |  0.00
Modify  | 0.39228    | 0.39228    | 0.39228    |   0.0 |  1.16
Other   |            | 0.06498    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5444.00 ave        5444 max        5444 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:      333224.0 ave      333224 max      333224 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333224
Ave neighs/atom = 166.61200
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 = 274.064156392278, Press = -6.50243492169102
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -8036.1137   -8036.1137   -8105.9527   -8105.9527    270.28421    270.28421    21583.312    21583.312   -1224.3593   -1224.3593 
   17000   -8032.0939   -8032.0939    -8105.154    -8105.154    282.75014    282.75014    21558.932    21558.932    539.09282    539.09282 
Loop time of 33.2906 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.595 ns/day, 9.247 hours/ns, 30.039 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    | 32.708     | 32.708     | 32.708     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12953    | 0.12953    | 0.12953    |   0.0 |  0.39
Output  | 0.0001548  | 0.0001548  | 0.0001548  |   0.0 |  0.00
Modify  | 0.38711    | 0.38711    | 0.38711    |   0.0 |  1.16
Other   |            | 0.06566    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5439.00 ave        5439 max        5439 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:      332416.0 ave      332416 max      332416 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332416
Ave neighs/atom = 166.20800
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 = 274.073658474152, Press = -4.74032827909786
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -8032.0939   -8032.0939    -8105.154    -8105.154    282.75014    282.75014    21558.932    21558.932    539.09282    539.09282 
   18000   -8036.8208   -8036.8208   -8106.3875   -8106.3875    269.23047    269.23047    21536.327    21536.327    1058.7971    1058.7971 
Loop time of 33.0837 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.612 ns/day, 9.190 hours/ns, 30.226 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    | 32.505     | 32.505     | 32.505     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12796    | 0.12796    | 0.12796    |   0.0 |  0.39
Output  | 0.00015445 | 0.00015445 | 0.00015445 |   0.0 |  0.00
Modify  | 0.38413    | 0.38413    | 0.38413    |   0.0 |  1.16
Other   |            | 0.06611    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5427.00 ave        5427 max        5427 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:      333084.0 ave      333084 max      333084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333084
Ave neighs/atom = 166.54200
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 = 274.104288783232, Press = -9.85112263729312
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -8036.8208   -8036.8208   -8106.3875   -8106.3875    269.23047    269.23047    21536.327    21536.327    1058.7971    1058.7971 
   19000   -8030.3228   -8030.3228   -8102.3191   -8102.3191    278.63315    278.63315     21501.35     21501.35    4216.5511    4216.5511 
Loop time of 32.8847 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.627 ns/day, 9.135 hours/ns, 30.409 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    | 32.311     | 32.311     | 32.311     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12705    | 0.12705    | 0.12705    |   0.0 |  0.39
Output  | 0.00015247 | 0.00015247 | 0.00015247 |   0.0 |  0.00
Modify  | 0.38166    | 0.38166    | 0.38166    |   0.0 |  1.16
Other   |            | 0.0651     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5437.00 ave        5437 max        5437 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:      333050.0 ave      333050 max      333050 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333050
Ave neighs/atom = 166.52500
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 = 274.206757422404, Press = -2.56942529569361
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -8030.3228   -8030.3228   -8102.3191   -8102.3191    278.63315    278.63315     21501.35     21501.35    4216.5511    4216.5511 
   20000   -8036.0502   -8036.0502     -8106.36     -8106.36    272.10625    272.10625    21596.412    21596.412   -1651.8627   -1651.8627 
Loop time of 32.5583 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.654 ns/day, 9.044 hours/ns, 30.714 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    | 31.989     | 31.989     | 31.989     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12604    | 0.12604    | 0.12604    |   0.0 |  0.39
Output  | 0.00019649 | 0.00019649 | 0.00019649 |   0.0 |  0.00
Modify  | 0.37783    | 0.37783    | 0.37783    |   0.0 |  1.16
Other   |            | 0.06495    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5439.00 ave        5439 max        5439 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:      333926.0 ave      333926 max      333926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333926
Ave neighs/atom = 166.96300
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 = 274.257928824481, Press = -5.63959611084081
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -8036.0502   -8036.0502     -8106.36     -8106.36    272.10625    272.10625    21596.412    21596.412   -1651.8627   -1651.8627 
   21000   -8033.2386   -8033.2386   -8106.8793   -8106.8793    284.99716    284.99716    21540.212    21540.212    749.32313    749.32313 
Loop time of 32.3562 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.670 ns/day, 8.988 hours/ns, 30.906 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    | 31.784     | 31.784     | 31.784     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12741    | 0.12741    | 0.12741    |   0.0 |  0.39
Output  | 0.00015221 | 0.00015221 | 0.00015221 |   0.0 |  0.00
Modify  | 0.37855    | 0.37855    | 0.37855    |   0.0 |  1.17
Other   |            | 0.06577    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5431.00 ave        5431 max        5431 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:      332452.0 ave      332452 max      332452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332452
Ave neighs/atom = 166.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 = 274.279636335894, Press = -5.43859927458001
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -8033.2386   -8033.2386   -8106.8793   -8106.8793    284.99716    284.99716    21540.212    21540.212    749.32313    749.32313 
   22000   -8035.9969   -8035.9969   -8106.8094   -8106.8094    274.05177    274.05177    21532.773    21532.773     1130.256     1130.256 
Loop time of 34.3182 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.518 ns/day, 9.533 hours/ns, 29.139 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    | 33.726     | 33.726     | 33.726     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1307     | 0.1307     | 0.1307     |   0.0 |  0.38
Output  | 0.00015528 | 0.00015528 | 0.00015528 |   0.0 |  0.00
Modify  | 0.3956     | 0.3956     | 0.3956     |   0.0 |  1.15
Other   |            | 0.06561    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5421.00 ave        5421 max        5421 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:      333320.0 ave      333320 max      333320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333320
Ave neighs/atom = 166.66000
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 = 274.197587454998, Press = -7.04910446499574
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -8035.9969   -8035.9969   -8106.8094   -8106.8094    274.05177    274.05177    21532.773    21532.773     1130.256     1130.256 
   23000   -8038.2668   -8038.2668   -8107.3648   -8107.3648    267.41657    267.41657      21549.6      21549.6    466.14918    466.14918 
Loop time of 32.4113 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.666 ns/day, 9.003 hours/ns, 30.853 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    | 31.844     | 31.844     | 31.844     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12747    | 0.12747    | 0.12747    |   0.0 |  0.39
Output  | 0.00015216 | 0.00015216 | 0.00015216 |   0.0 |  0.00
Modify  | 0.375      | 0.375      | 0.375      |   0.0 |  1.16
Other   |            | 0.06468    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5428.00 ave        5428 max        5428 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:      333482.0 ave      333482 max      333482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333482
Ave neighs/atom = 166.74100
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 = 274.140923474447, Press = -5.22873172474621
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -8038.2668   -8038.2668   -8107.3648   -8107.3648    267.41657    267.41657      21549.6      21549.6    466.14918    466.14918 
   24000   -8035.6867   -8035.6867   -8106.7834   -8106.7834    275.15171    275.15171    21508.855    21508.855    2384.1335    2384.1335 
Loop time of 33.4109 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.586 ns/day, 9.281 hours/ns, 29.930 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    | 32.831     | 32.831     | 32.831     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12812    | 0.12812    | 0.12812    |   0.0 |  0.38
Output  | 0.00015423 | 0.00015423 | 0.00015423 |   0.0 |  0.00
Modify  | 0.38627    | 0.38627    | 0.38627    |   0.0 |  1.16
Other   |            | 0.06554    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5425.00 ave        5425 max        5425 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:      333154.0 ave      333154 max      333154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333154
Ave neighs/atom = 166.57700
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 = 274.13467633011, Press = -7.56484464262351
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -8035.6867   -8035.6867   -8106.7834   -8106.7834    275.15171    275.15171    21508.855    21508.855    2384.1335    2384.1335 
   25000   -8034.0724   -8034.0724   -8106.6974   -8106.6974    281.06639    281.06639    21562.507    21562.507   -1389.7786   -1389.7786 
Loop time of 33.6046 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.571 ns/day, 9.335 hours/ns, 29.758 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    | 33.025     | 33.025     | 33.025     |   0.0 | 98.28
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12879    | 0.12879    | 0.12879    |   0.0 |  0.38
Output  | 0.00015309 | 0.00015309 | 0.00015309 |   0.0 |  0.00
Modify  | 0.38583    | 0.38583    | 0.38583    |   0.0 |  1.15
Other   |            | 0.06455    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5426.00 ave        5426 max        5426 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:      333880.0 ave      333880 max      333880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333880
Ave neighs/atom = 166.94000
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 = 274.08715106147, Press = -3.18825681214154
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -8034.0724   -8034.0724   -8106.6974   -8106.6974    281.06639    281.06639    21562.507    21562.507   -1389.7786   -1389.7786 
   26000     -8037.28     -8037.28   -8109.1804   -8109.1804    278.26207    278.26207    21550.965    21550.965   -200.28443   -200.28443 
Loop time of 32.3492 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.671 ns/day, 8.986 hours/ns, 30.913 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    | 31.785     | 31.785     | 31.785     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12651    | 0.12651    | 0.12651    |   0.0 |  0.39
Output  | 0.0001536  | 0.0001536  | 0.0001536  |   0.0 |  0.00
Modify  | 0.37336    | 0.37336    | 0.37336    |   0.0 |  1.15
Other   |            | 0.06455    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5424.00 ave        5424 max        5424 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:      332846.0 ave      332846 max      332846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332846
Ave neighs/atom = 166.42300
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 = 274.16895418949, Press = -3.06470333697202
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000     -8037.28     -8037.28   -8109.1804   -8109.1804    278.26207    278.26207    21550.965    21550.965   -200.28443   -200.28443 
   27000   -8034.3151   -8034.3151   -8104.0699   -8104.0699    269.95824    269.95824    21508.077    21508.077    3865.6371    3865.6371 
Loop time of 31.8094 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.716 ns/day, 8.836 hours/ns, 31.437 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    | 31.25      | 31.25      | 31.25      |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12557    | 0.12557    | 0.12557    |   0.0 |  0.39
Output  | 0.0002005  | 0.0002005  | 0.0002005  |   0.0 |  0.00
Modify  | 0.36934    | 0.36934    | 0.36934    |   0.0 |  1.16
Other   |            | 0.06444    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5446.00 ave        5446 max        5446 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:      332982.0 ave      332982 max      332982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332982
Ave neighs/atom = 166.49100
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 = 274.153865720633, Press = -4.18690149101642
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -8034.3151   -8034.3151   -8104.0699   -8104.0699    269.95824    269.95824    21508.077    21508.077    3865.6371    3865.6371 
   28000   -8035.7813   -8035.7813   -8106.8613   -8106.8613    275.08687    275.08687    21583.539    21583.539   -1035.5439   -1035.5439 
Loop time of 33.9708 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.543 ns/day, 9.436 hours/ns, 29.437 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    | 33.384     | 33.384     | 33.384     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12923    | 0.12923    | 0.12923    |   0.0 |  0.38
Output  | 0.00019492 | 0.00019492 | 0.00019492 |   0.0 |  0.00
Modify  | 0.39261    | 0.39261    | 0.39261    |   0.0 |  1.16
Other   |            | 0.06527    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5411.00 ave        5411 max        5411 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:      333706.0 ave      333706 max      333706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333706
Ave neighs/atom = 166.85300
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 = 274.150448966854, Press = -8.18193374835064
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -8035.7813   -8035.7813   -8106.8613   -8106.8613    275.08687    275.08687    21583.539    21583.539   -1035.5439   -1035.5439 
   29000   -8034.2726   -8034.2726   -8105.6301   -8105.6301     276.1609     276.1609     21591.39     21591.39   -2190.7172   -2190.7172 
Loop time of 33.1989 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.602 ns/day, 9.222 hours/ns, 30.121 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    | 32.619     | 32.619     | 32.619     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12799    | 0.12799    | 0.12799    |   0.0 |  0.39
Output  | 0.00015261 | 0.00015261 | 0.00015261 |   0.0 |  0.00
Modify  | 0.38652    | 0.38652    | 0.38652    |   0.0 |  1.16
Other   |            | 0.06493    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5421.00 ave        5421 max        5421 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:      332502.0 ave      332502 max      332502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332502
Ave neighs/atom = 166.25100
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 = 274.224887754396, Press = -5.43086204038187
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -8034.2726   -8034.2726   -8105.6301   -8105.6301     276.1609     276.1609     21591.39     21591.39   -2190.7172   -2190.7172 
   30000   -8032.8551   -8032.8551   -8104.3754   -8104.3754    276.79093    276.79093    21575.412    21575.412   -1345.6239   -1345.6239 
Loop time of 32.0885 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.693 ns/day, 8.913 hours/ns, 31.164 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    | 31.525     | 31.525     | 31.525     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.126      | 0.126      | 0.126      |   0.0 |  0.39
Output  | 0.00015022 | 0.00015022 | 0.00015022 |   0.0 |  0.00
Modify  | 0.37288    | 0.37288    | 0.37288    |   0.0 |  1.16
Other   |            | 0.06485    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5438.00 ave        5438 max        5438 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:      332252.0 ave      332252 max      332252 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332252
Ave neighs/atom = 166.12600
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 = 274.182863218313, Press = -4.04122253842444
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -8032.8551   -8032.8551   -8104.3754   -8104.3754    276.79093    276.79093    21575.412    21575.412   -1345.6239   -1345.6239 
   31000   -8034.8187   -8034.8187   -8104.1022   -8104.1022    268.13439    268.13439        21557        21557    341.02323    341.02323 
Loop time of 34.7666 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.485 ns/day, 9.657 hours/ns, 28.763 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    | 34.164     | 34.164     | 34.164     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1333     | 0.1333     | 0.1333     |   0.0 |  0.38
Output  | 0.00019015 | 0.00019015 | 0.00019015 |   0.0 |  0.00
Modify  | 0.40316    | 0.40316    | 0.40316    |   0.0 |  1.16
Other   |            | 0.0658     |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5441.00 ave        5441 max        5441 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:      332622.0 ave      332622 max      332622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332622
Ave neighs/atom = 166.31100
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 = 274.172572573909, Press = -2.65588369704678
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -8034.8187   -8034.8187   -8104.1022   -8104.1022    268.13439    268.13439        21557        21557    341.02323    341.02323 
   32000   -8036.0934   -8036.0934    -8106.561    -8106.561    272.71678    272.71678    21530.586    21530.586    2156.0849    2156.0849 
Loop time of 33.0876 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.611 ns/day, 9.191 hours/ns, 30.223 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    | 32.509     | 32.509     | 32.509     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12854    | 0.12854    | 0.12854    |   0.0 |  0.39
Output  | 0.00015512 | 0.00015512 | 0.00015512 |   0.0 |  0.00
Modify  | 0.3857     | 0.3857     | 0.3857     |   0.0 |  1.17
Other   |            | 0.06458    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5428.00 ave        5428 max        5428 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:      332880.0 ave      332880 max      332880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332880
Ave neighs/atom = 166.44000
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 = 274.040865639338, Press = -2.90610128577512
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -8036.0934   -8036.0934    -8106.561    -8106.561    272.71678    272.71678    21530.586    21530.586    2156.0849    2156.0849 
   33000   -8035.5594   -8035.5594   -8104.8953   -8104.8953     268.3369     268.3369    21522.824    21522.824    2796.2048    2796.2048 
Loop time of 32.9485 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.622 ns/day, 9.152 hours/ns, 30.350 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    | 32.375     | 32.375     | 32.375     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12691    | 0.12691    | 0.12691    |   0.0 |  0.39
Output  | 0.00019008 | 0.00019008 | 0.00019008 |   0.0 |  0.00
Modify  | 0.38096    | 0.38096    | 0.38096    |   0.0 |  1.16
Other   |            | 0.06514    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5416.00 ave        5416 max        5416 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:      333262.0 ave      333262 max      333262 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333262
Ave neighs/atom = 166.63100
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 = 274.021154674715, Press = -5.48445524173888
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -8035.5594   -8035.5594   -8104.8953   -8104.8953     268.3369     268.3369    21522.824    21522.824    2796.2048    2796.2048 
   34000   -8035.8695   -8035.8695   -8107.1905   -8107.1905    276.01953    276.01953    21540.046    21540.046    1228.2216    1228.2216 
Loop time of 33.6421 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.568 ns/day, 9.345 hours/ns, 29.725 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    | 33.055     | 33.055     | 33.055     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12968    | 0.12968    | 0.12968    |   0.0 |  0.39
Output  | 0.00015782 | 0.00015782 | 0.00015782 |   0.0 |  0.00
Modify  | 0.39161    | 0.39161    | 0.39161    |   0.0 |  1.16
Other   |            | 0.06521    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5419.00 ave        5419 max        5419 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:      333308.0 ave      333308 max      333308 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333308
Ave neighs/atom = 166.65400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.919333054046, Press = -3.61652345908385
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -8035.8695   -8035.8695   -8107.1905   -8107.1905    276.01953    276.01953    21540.046    21540.046    1228.2216    1228.2216 
   35000   -8034.5976   -8034.5976   -8105.1371   -8105.1371     272.9948     272.9948     21542.47     21542.47    1646.7611    1646.7611 
Loop time of 33.6603 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.567 ns/day, 9.350 hours/ns, 29.709 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    | 33.076     | 33.076     | 33.076     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12971    | 0.12971    | 0.12971    |   0.0 |  0.39
Output  | 0.00020447 | 0.00020447 | 0.00020447 |   0.0 |  0.00
Modify  | 0.38828    | 0.38828    | 0.38828    |   0.0 |  1.15
Other   |            | 0.06582    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5436.00 ave        5436 max        5436 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:      332962.0 ave      332962 max      332962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332962
Ave neighs/atom = 166.48100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.854448531283, Press = -2.8968512641888
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -8034.5976   -8034.5976   -8105.1371   -8105.1371     272.9948     272.9948     21542.47     21542.47    1646.7611    1646.7611 
   36000   -8041.7788   -8041.7788   -8108.5244   -8108.5244    258.31255    258.31255    21519.283    21519.283    2330.0458    2330.0458 
Loop time of 32.3498 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.671 ns/day, 8.986 hours/ns, 30.912 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    | 31.782     | 31.782     | 31.782     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12586    | 0.12586    | 0.12586    |   0.0 |  0.39
Output  | 0.00015246 | 0.00015246 | 0.00015246 |   0.0 |  0.00
Modify  | 0.37676    | 0.37676    | 0.37676    |   0.0 |  1.16
Other   |            | 0.0648     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5436.00 ave        5436 max        5436 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:      333086.0 ave      333086 max      333086 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333086
Ave neighs/atom = 166.54300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.757952723589, Press = -0.760245929748605
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -8041.7788   -8041.7788   -8108.5244   -8108.5244    258.31255    258.31255    21519.283    21519.283    2330.0458    2330.0458 
   37000    -8034.883    -8034.883   -8104.2468   -8104.2468    268.44494    268.44494    21561.146    21561.146   -256.93794   -256.93794 
Loop time of 33.7909 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.557 ns/day, 9.386 hours/ns, 29.594 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    | 33.199     | 33.199     | 33.199     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13116    | 0.13116    | 0.13116    |   0.0 |  0.39
Output  | 0.00015396 | 0.00015396 | 0.00015396 |   0.0 |  0.00
Modify  | 0.39542    | 0.39542    | 0.39542    |   0.0 |  1.17
Other   |            | 0.06536    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5414.00 ave        5414 max        5414 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:      333586.0 ave      333586 max      333586 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333586
Ave neighs/atom = 166.79300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.721331255904, Press = -3.97965411629808
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000    -8034.883    -8034.883   -8104.2468   -8104.2468    268.44494    268.44494    21561.146    21561.146   -256.93794   -256.93794 
   38000   -8034.5475   -8034.5475   -8106.6576   -8106.6576    279.07349    279.07349    21570.345    21570.345   -870.83384   -870.83384 
Loop time of 32.1004 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.692 ns/day, 8.917 hours/ns, 31.152 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    | 31.537     | 31.537     | 31.537     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12526    | 0.12526    | 0.12526    |   0.0 |  0.39
Output  | 0.00020179 | 0.00020179 | 0.00020179 |   0.0 |  0.00
Modify  | 0.37322    | 0.37322    | 0.37322    |   0.0 |  1.16
Other   |            | 0.06501    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5429.00 ave        5429 max        5429 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:      332712.0 ave      332712 max      332712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332712
Ave neighs/atom = 166.35600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.735257709125, Press = -2.98044124213455
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -8034.5475   -8034.5475   -8106.6576   -8106.6576    279.07349    279.07349    21570.345    21570.345   -870.83384   -870.83384 
   39000   -8037.4372   -8037.4372   -8107.1769   -8107.1769    269.89968    269.89968    21513.166    21513.166    2602.5885    2602.5885 
Loop time of 31.8017 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.717 ns/day, 8.834 hours/ns, 31.445 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    | 31.244     | 31.244     | 31.244     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12502    | 0.12502    | 0.12502    |   0.0 |  0.39
Output  | 0.00019542 | 0.00019542 | 0.00019542 |   0.0 |  0.00
Modify  | 0.36838    | 0.36838    | 0.36838    |   0.0 |  1.16
Other   |            | 0.06423    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5407.00 ave        5407 max        5407 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:      332776.0 ave      332776 max      332776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332776
Ave neighs/atom = 166.38800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.742350932956, Press = -3.16342294012877
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -8037.4372   -8037.4372   -8107.1769   -8107.1769    269.89968    269.89968    21513.166    21513.166    2602.5885    2602.5885 
   40000   -8035.3624   -8035.3624   -8106.0754   -8106.0754    273.66662    273.66662    21545.212    21545.212    680.45844    680.45844 
Loop time of 32.6849 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.643 ns/day, 9.079 hours/ns, 30.595 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    | 32.113     | 32.113     | 32.113     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12766    | 0.12766    | 0.12766    |   0.0 |  0.39
Output  | 0.00014529 | 0.00014529 | 0.00014529 |   0.0 |  0.00
Modify  | 0.37862    | 0.37862    | 0.37862    |   0.0 |  1.16
Other   |            | 0.06517    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5445.00 ave        5445 max        5445 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:      333672.0 ave      333672 max      333672 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333672
Ave neighs/atom = 166.83600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.71787090451, Press = -2.5978600476707
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -8035.3624   -8035.3624   -8106.0754   -8106.0754    273.66662    273.66662    21545.212    21545.212    680.45844    680.45844 
   41000   -8037.1884   -8037.1884    -8107.712    -8107.712    272.93377    272.93377     21595.62     21595.62   -1240.8864   -1240.8864 
Loop time of 33.7202 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.562 ns/day, 9.367 hours/ns, 29.656 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    | 33.131     | 33.131     | 33.131     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13032    | 0.13032    | 0.13032    |   0.0 |  0.39
Output  | 0.00015386 | 0.00015386 | 0.00015386 |   0.0 |  0.00
Modify  | 0.39388    | 0.39388    | 0.39388    |   0.0 |  1.17
Other   |            | 0.06521    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5420.00 ave        5420 max        5420 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:      333242.0 ave      333242 max      333242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333242
Ave neighs/atom = 166.62100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.610073578117, Press = -0.971960378491989
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -8037.1884   -8037.1884    -8107.712    -8107.712    272.93377    272.93377     21595.62     21595.62   -1240.8864   -1240.8864 
   42000   -8035.6269   -8035.6269   -8106.2105   -8106.2105    273.16587    273.16587    21600.183    21600.183   -3547.6836   -3547.6836 
Loop time of 33.0086 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.618 ns/day, 9.169 hours/ns, 30.295 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    | 32.431     | 32.431     | 32.431     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12763    | 0.12763    | 0.12763    |   0.0 |  0.39
Output  | 0.0001519  | 0.0001519  | 0.0001519  |   0.0 |  0.00
Modify  | 0.38423    | 0.38423    | 0.38423    |   0.0 |  1.16
Other   |            | 0.06518    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5397.00 ave        5397 max        5397 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:      332150.0 ave      332150 max      332150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332150
Ave neighs/atom = 166.07500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.609730521306, Press = 0.335024936334808
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -8035.6269   -8035.6269   -8106.2105   -8106.2105    273.16587    273.16587    21600.183    21600.183   -3547.6836   -3547.6836 
   43000   -8033.3755   -8033.3755   -8104.6098   -8104.6098    275.68423    275.68423    21589.081    21589.081    -1367.642    -1367.642 
Loop time of 34.2634 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.522 ns/day, 9.518 hours/ns, 29.186 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    | 33.678     | 33.678     | 33.678     |   0.0 | 98.29
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1291     | 0.1291     | 0.1291     |   0.0 |  0.38
Output  | 0.0001556  | 0.0001556  | 0.0001556  |   0.0 |  0.00
Modify  | 0.39125    | 0.39125    | 0.39125    |   0.0 |  1.14
Other   |            | 0.06526    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5420.00 ave        5420 max        5420 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:      332320.0 ave      332320 max      332320 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332320
Ave neighs/atom = 166.16000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.570356263156, Press = -1.63073139169026
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -8033.3755   -8033.3755   -8104.6098   -8104.6098    275.68423    275.68423    21589.081    21589.081    -1367.642    -1367.642 
   44000   -8037.5763   -8037.5763   -8108.5918   -8108.5918    274.83738    274.83738    21496.948    21496.948    3727.1902    3727.1902 
Loop time of 32.999 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.618 ns/day, 9.166 hours/ns, 30.304 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    | 32.42      | 32.42      | 32.42      |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1281     | 0.1281     | 0.1281     |   0.0 |  0.39
Output  | 0.00015414 | 0.00015414 | 0.00015414 |   0.0 |  0.00
Modify  | 0.38516    | 0.38516    | 0.38516    |   0.0 |  1.17
Other   |            | 0.0652     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5427.00 ave        5427 max        5427 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:      332522.0 ave      332522 max      332522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332522
Ave neighs/atom = 166.26100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.546215086073, Press = -1.69907228324732
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -8037.5763   -8037.5763   -8108.5918   -8108.5918    274.83738    274.83738    21496.948    21496.948    3727.1902    3727.1902 
   45000   -8035.7721   -8035.7721    -8106.516    -8106.516    273.78658    273.78658    21572.412    21572.412   -583.11887   -583.11887 
Loop time of 32.3528 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.671 ns/day, 8.987 hours/ns, 30.909 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    | 31.789     | 31.789     | 31.789     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12589    | 0.12589    | 0.12589    |   0.0 |  0.39
Output  | 0.00015001 | 0.00015001 | 0.00015001 |   0.0 |  0.00
Modify  | 0.37355    | 0.37355    | 0.37355    |   0.0 |  1.15
Other   |            | 0.06431    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5425.00 ave        5425 max        5425 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:      333810.0 ave      333810 max      333810 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333810
Ave neighs/atom = 166.90500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.553331894363, Press = -3.90806366515027
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -8035.7721   -8035.7721    -8106.516    -8106.516    273.78658    273.78658    21572.412    21572.412   -583.11887   -583.11887 
   46000   -8031.7483   -8031.7483   -8104.4142   -8104.4142    281.22453    281.22453    21577.861    21577.861   -168.49563   -168.49563 
Loop time of 33.2837 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.596 ns/day, 9.245 hours/ns, 30.045 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    | 32.699     | 32.699     | 32.699     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12925    | 0.12925    | 0.12925    |   0.0 |  0.39
Output  | 0.00014981 | 0.00014981 | 0.00014981 |   0.0 |  0.00
Modify  | 0.38964    | 0.38964    | 0.38964    |   0.0 |  1.17
Other   |            | 0.06575    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5422.00 ave        5422 max        5422 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:      332638.0 ave      332638 max      332638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332638
Ave neighs/atom = 166.31900
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.563420891181, Press = -2.7738088226501
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -8031.7483   -8031.7483   -8104.4142   -8104.4142    281.22453    281.22453    21577.861    21577.861   -168.49563   -168.49563 
   47000   -8037.7584   -8037.7584   -8108.7054   -8108.7054    274.57222    274.57222    21552.425    21552.425    234.12063    234.12063 
Loop time of 33.3091 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.594 ns/day, 9.253 hours/ns, 30.022 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    | 32.726     | 32.726     | 32.726     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12907    | 0.12907    | 0.12907    |   0.0 |  0.39
Output  | 0.00015181 | 0.00015181 | 0.00015181 |   0.0 |  0.00
Modify  | 0.38858    | 0.38858    | 0.38858    |   0.0 |  1.17
Other   |            | 0.06544    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5426.00 ave        5426 max        5426 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:      332606.0 ave      332606 max      332606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332606
Ave neighs/atom = 166.30300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.572995419597, Press = -0.878606744410569
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -8037.7584   -8037.7584   -8108.7054   -8108.7054    274.57222    274.57222    21552.425    21552.425    234.12063    234.12063 
   48000    -8035.157    -8035.157   -8105.7244   -8105.7244    273.10318    273.10318    21568.334    21568.334    181.90244    181.90244 
Loop time of 32.6253 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.648 ns/day, 9.063 hours/ns, 30.651 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    | 32.054     | 32.054     | 32.054     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12708    | 0.12708    | 0.12708    |   0.0 |  0.39
Output  | 0.00020284 | 0.00020284 | 0.00020284 |   0.0 |  0.00
Modify  | 0.37885    | 0.37885    | 0.37885    |   0.0 |  1.16
Other   |            | 0.06471    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5435.00 ave        5435 max        5435 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:      333106.0 ave      333106 max      333106 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333106
Ave neighs/atom = 166.55300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.505146534609, Press = -2.29470056470099
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000    -8035.157    -8035.157   -8105.7244   -8105.7244    273.10318    273.10318    21568.334    21568.334    181.90244    181.90244 
   49000   -8039.0481   -8039.0481   -8108.3376   -8108.3376    268.15763    268.15763    21525.145    21525.145    528.06231    528.06231 
Loop time of 32.9536 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.622 ns/day, 9.154 hours/ns, 30.346 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    | 32.381     | 32.381     | 32.381     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12796    | 0.12796    | 0.12796    |   0.0 |  0.39
Output  | 0.00015623 | 0.00015623 | 0.00015623 |   0.0 |  0.00
Modify  | 0.38011    | 0.38011    | 0.38011    |   0.0 |  1.15
Other   |            | 0.06429    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5432.00 ave        5432 max        5432 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:      332752.0 ave      332752 max      332752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332752
Ave neighs/atom = 166.37600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.467922392309, Press = -2.41713508888213
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -8039.0481   -8039.0481   -8108.3376   -8108.3376    268.15763    268.15763    21525.145    21525.145    528.06231    528.06231 
   50000   -8035.3022   -8035.3022   -8106.0581   -8106.0581    273.83284    273.83284    21572.689    21572.689   -1219.2493   -1219.2493 
Loop time of 33.7899 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.557 ns/day, 9.386 hours/ns, 29.595 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    | 33.202     | 33.202     | 33.202     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13029    | 0.13029    | 0.13029    |   0.0 |  0.39
Output  | 0.00015528 | 0.00015528 | 0.00015528 |   0.0 |  0.00
Modify  | 0.3923     | 0.3923     | 0.3923     |   0.0 |  1.16
Other   |            | 0.06527    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5413.00 ave        5413 max        5413 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:      333160.0 ave      333160 max      333160 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333160
Ave neighs/atom = 166.58000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.41038374971, Press = -1.19545890615042
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -8035.3022   -8035.3022   -8106.0581   -8106.0581    273.83284    273.83284    21572.689    21572.689   -1219.2493   -1219.2493 
   51000   -8037.8452   -8037.8452   -8106.6203   -8106.6203    266.16664    266.16664    21537.204    21537.204    715.37378    715.37378 
Loop time of 32.5867 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.651 ns/day, 9.052 hours/ns, 30.687 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    | 32.016     | 32.016     | 32.016     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12712    | 0.12712    | 0.12712    |   0.0 |  0.39
Output  | 0.00019377 | 0.00019377 | 0.00019377 |   0.0 |  0.00
Modify  | 0.37827    | 0.37827    | 0.37827    |   0.0 |  1.16
Other   |            | 0.06514    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5433.00 ave        5433 max        5433 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:      332572.0 ave      332572 max      332572 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332572
Ave neighs/atom = 166.28600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.386458583423, Press = -3.11772200296375
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -8037.8452   -8037.8452   -8106.6203   -8106.6203    266.16664    266.16664    21537.204    21537.204    715.37378    715.37378 
   52000   -8034.1453   -8034.1453   -8105.9197   -8105.9197    277.77462    277.77462    21577.408    21577.408   -712.93404   -712.93404 
Loop time of 33.4041 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.587 ns/day, 9.279 hours/ns, 29.936 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    | 32.821     | 32.821     | 32.821     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12927    | 0.12927    | 0.12927    |   0.0 |  0.39
Output  | 0.0001497  | 0.0001497  | 0.0001497  |   0.0 |  0.00
Modify  | 0.38784    | 0.38784    | 0.38784    |   0.0 |  1.16
Other   |            | 0.06575    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5417.00 ave        5417 max        5417 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:      333154.0 ave      333154 max      333154 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333154
Ave neighs/atom = 166.57700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.342463482874, Press = -2.67210246986524
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -8034.1453   -8034.1453   -8105.9197   -8105.9197    277.77462    277.77462    21577.408    21577.408   -712.93404   -712.93404 
   53000    -8035.626    -8035.626   -8106.4149   -8106.4149    273.96026    273.96026    21596.518    21596.518   -1930.7354   -1930.7354 
Loop time of 32.8557 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.630 ns/day, 9.127 hours/ns, 30.436 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    | 32.28      | 32.28      | 32.28      |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12749    | 0.12749    | 0.12749    |   0.0 |  0.39
Output  | 0.00015403 | 0.00015403 | 0.00015403 |   0.0 |  0.00
Modify  | 0.38272    | 0.38272    | 0.38272    |   0.0 |  1.16
Other   |            | 0.06524    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5438.00 ave        5438 max        5438 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:      332674.0 ave      332674 max      332674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332674
Ave neighs/atom = 166.33700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.30999308554, Press = -1.59188581237814
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000    -8035.626    -8035.626   -8106.4149   -8106.4149    273.96026    273.96026    21596.518    21596.518   -1930.7354   -1930.7354 
   54000   -8033.2769   -8033.2769    -8104.603    -8104.603    276.03934    276.03934    21561.552    21561.552    400.54077    400.54077 
Loop time of 32.1855 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.684 ns/day, 8.940 hours/ns, 31.070 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    | 31.623     | 31.623     | 31.623     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12561    | 0.12561    | 0.12561    |   0.0 |  0.39
Output  | 0.00015293 | 0.00015293 | 0.00015293 |   0.0 |  0.00
Modify  | 0.37172    | 0.37172    | 0.37172    |   0.0 |  1.15
Other   |            | 0.06477    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5419.00 ave        5419 max        5419 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:      332482.0 ave      332482 max      332482 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332482
Ave neighs/atom = 166.24100
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.316235730707, Press = -2.62704725456594
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -8033.2769   -8033.2769    -8104.603    -8104.603    276.03934    276.03934    21561.552    21561.552    400.54077    400.54077 
   55000   -8032.7122   -8032.7122   -8104.7001   -8104.7001    278.60036    278.60036    21591.298    21591.298   -780.14063   -780.14063 
Loop time of 32.5772 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.652 ns/day, 9.049 hours/ns, 30.696 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    | 32.004     | 32.004     | 32.004     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12936    | 0.12936    | 0.12936    |   0.0 |  0.40
Output  | 0.00015336 | 0.00015336 | 0.00015336 |   0.0 |  0.00
Modify  | 0.3785     | 0.3785     | 0.3785     |   0.0 |  1.16
Other   |            | 0.06541    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5427.00 ave        5427 max        5427 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:      332854.0 ave      332854 max      332854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332854
Ave neighs/atom = 166.42700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.306386295484, Press = -1.06626129516424
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -8032.7122   -8032.7122   -8104.7001   -8104.7001    278.60036    278.60036    21591.298    21591.298   -780.14063   -780.14063 
   56000   -8035.6743   -8035.6743   -8106.7157   -8106.7157    274.93766    274.93766    21548.708    21548.708    984.06513    984.06513 
Loop time of 31.8092 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.716 ns/day, 8.836 hours/ns, 31.437 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    | 31.251     | 31.251     | 31.251     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12517    | 0.12517    | 0.12517    |   0.0 |  0.39
Output  | 0.00015339 | 0.00015339 | 0.00015339 |   0.0 |  0.00
Modify  | 0.36858    | 0.36858    | 0.36858    |   0.0 |  1.16
Other   |            | 0.06455    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5423.00 ave        5423 max        5423 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:      332288.0 ave      332288 max      332288 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332288
Ave neighs/atom = 166.14400
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.280476979331, Press = -1.01506637670995
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -8035.6743   -8035.6743   -8106.7157   -8106.7157    274.93766    274.93766    21548.708    21548.708    984.06513    984.06513 
   57000   -8033.0205   -8033.0205   -8105.0894   -8105.0894    278.91399    278.91399    21553.322    21553.322     865.5668     865.5668 
Loop time of 31.8315 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.714 ns/day, 8.842 hours/ns, 31.415 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    | 31.273     | 31.273     | 31.273     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12427    | 0.12427    | 0.12427    |   0.0 |  0.39
Output  | 0.00015774 | 0.00015774 | 0.00015774 |   0.0 |  0.00
Modify  | 0.36912    | 0.36912    | 0.36912    |   0.0 |  1.16
Other   |            | 0.06474    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5406.00 ave        5406 max        5406 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:      333294.0 ave      333294 max      333294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333294
Ave neighs/atom = 166.64700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.260363878297, Press = -2.29672582973773
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -8033.0205   -8033.0205   -8105.0894   -8105.0894    278.91399    278.91399    21553.322    21553.322     865.5668     865.5668 
   58000   -8036.3684   -8036.3684   -8104.1233   -8104.1233    262.21825    262.21825      21554.4      21554.4    957.98297    957.98297 
Loop time of 32.8921 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.627 ns/day, 9.137 hours/ns, 30.402 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 32.318     | 32.318     | 32.318     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12787    | 0.12787    | 0.12787    |   0.0 |  0.39
Output  | 0.0001545  | 0.0001545  | 0.0001545  |   0.0 |  0.00
Modify  | 0.38099    | 0.38099    | 0.38099    |   0.0 |  1.16
Other   |            | 0.0655     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5440.00 ave        5440 max        5440 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:      333094.0 ave      333094 max      333094 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 333094
Ave neighs/atom = 166.54700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.26329068815, Press = -1.78717121880946
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -8036.3684   -8036.3684   -8104.1233   -8104.1233    262.21825    262.21825      21554.4      21554.4    957.98297    957.98297 
   59000   -8035.1333   -8035.1333   -8106.0057   -8106.0057    274.28344    274.28344    21568.562    21568.562    200.87386    200.87386 
Loop time of 34.2866 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.520 ns/day, 9.524 hours/ns, 29.166 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    | 33.695     | 33.695     | 33.695     |   0.0 | 98.27
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.13066    | 0.13066    | 0.13066    |   0.0 |  0.38
Output  | 0.00019858 | 0.00019858 | 0.00019858 |   0.0 |  0.00
Modify  | 0.39452    | 0.39452    | 0.39452    |   0.0 |  1.15
Other   |            | 0.06629    |            |       |  0.19

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5434.00 ave        5434 max        5434 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:      332654.0 ave      332654 max      332654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332654
Ave neighs/atom = 166.32700
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.256903016333, Press = -2.09226892961079
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -8035.1333   -8035.1333   -8106.0057   -8106.0057    274.28344    274.28344    21568.562    21568.562    200.87386    200.87386 
   60000   -8035.2772   -8035.2772    -8106.912    -8106.912    277.23391    277.23391    21577.129    21577.129   -977.99416   -977.99416 
Loop time of 32.908 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.626 ns/day, 9.141 hours/ns, 30.388 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    | 32.333     | 32.333     | 32.333     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12734    | 0.12734    | 0.12734    |   0.0 |  0.39
Output  | 0.00015298 | 0.00015298 | 0.00015298 |   0.0 |  0.00
Modify  | 0.3825     | 0.3825     | 0.3825     |   0.0 |  1.16
Other   |            | 0.0646     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5422.00 ave        5422 max        5422 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:      332820.0 ave      332820 max      332820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332820
Ave neighs/atom = 166.41000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.218522100211, Press = -1.66970819528757
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -8035.2772   -8035.2772    -8106.912    -8106.912    277.23391    277.23391    21577.129    21577.129   -977.99416   -977.99416 
   61000   -8031.2261   -8031.2261   -8103.6417   -8103.6417    280.25612    280.25612    21560.956    21560.956    662.19794    662.19794 
Loop time of 32.3773 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.669 ns/day, 8.994 hours/ns, 30.886 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    | 31.811     | 31.811     | 31.811     |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12643    | 0.12643    | 0.12643    |   0.0 |  0.39
Output  | 0.00014986 | 0.00014986 | 0.00014986 |   0.0 |  0.00
Modify  | 0.37557    | 0.37557    | 0.37557    |   0.0 |  1.16
Other   |            | 0.06437    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5408.00 ave        5408 max        5408 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:      332266.0 ave      332266 max      332266 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332266
Ave neighs/atom = 166.13300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.260758476626, Press = -0.852676544179462
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -8031.2261   -8031.2261   -8103.6417   -8103.6417    280.25612    280.25612    21560.956    21560.956    662.19794    662.19794 
   62000   -8037.2199   -8037.2199   -8107.0978   -8107.0978    270.43473    270.43473    21565.087    21565.087   -794.97917   -794.97917 
Loop time of 31.7805 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.719 ns/day, 8.828 hours/ns, 31.466 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    | 31.222     | 31.222     | 31.222     |   0.0 | 98.24
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12443    | 0.12443    | 0.12443    |   0.0 |  0.39
Output  | 0.00015481 | 0.00015481 | 0.00015481 |   0.0 |  0.00
Modify  | 0.36999    | 0.36999    | 0.36999    |   0.0 |  1.16
Other   |            | 0.06424    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5415.00 ave        5415 max        5415 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:      332826.0 ave      332826 max      332826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332826
Ave neighs/atom = 166.41300
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.264966225041, Press = -2.70966300011941
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -8037.2199   -8037.2199   -8107.0978   -8107.0978    270.43473    270.43473    21565.087    21565.087   -794.97917   -794.97917 
   63000    -8031.909    -8031.909    -8102.212    -8102.212    272.08006    272.08006    21608.373    21608.373   -2419.6903   -2419.6903 
Loop time of 32.7521 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.638 ns/day, 9.098 hours/ns, 30.532 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    | 32.181     | 32.181     | 32.181     |   0.0 | 98.26
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12768    | 0.12768    | 0.12768    |   0.0 |  0.39
Output  | 0.00015175 | 0.00015175 | 0.00015175 |   0.0 |  0.00
Modify  | 0.37794    | 0.37794    | 0.37794    |   0.0 |  1.15
Other   |            | 0.06484    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5428.00 ave        5428 max        5428 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:      332872.0 ave      332872 max      332872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332872
Ave neighs/atom = 166.43600
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.294046213445, Press = -1.15687088151184
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.6
  ghost atom cutoff = 7.6
  binsize = 3.8, bins = 8 8 8
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 7.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.577 | 4.577 | 4.577 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000    -8031.909    -8031.909    -8102.212    -8102.212    272.08006    272.08006    21608.373    21608.373   -2419.6903   -2419.6903 
   64000   -8036.4552   -8036.4552   -8106.6872   -8106.6872    271.80508    271.80508    21481.124    21481.124    5299.3361    5299.3361 
Loop time of 32.1507 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.687 ns/day, 8.931 hours/ns, 31.104 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    | 31.59      | 31.59      | 31.59      |   0.0 | 98.25
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12462    | 0.12462    | 0.12462    |   0.0 |  0.39
Output  | 0.00015434 | 0.00015434 | 0.00015434 |   0.0 |  0.00
Modify  | 0.37152    | 0.37152    | 0.37152    |   0.0 |  1.16
Other   |            | 0.06489    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5434.00 ave        5434 max        5434 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:      332336.0 ave      332336 max      332336 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 332336
Ave neighs/atom = 166.16800
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
jump SELF break

# Write final averaged volume to file if temperature and volume have converged; otherwise wirte a
# flag to indicate non-convergence.
variable      myStep equal step
if "${myStep} < 2000000" then "print '${V}'  file output/vol_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
21560.4047691659

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0