# 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.938573218882084*${_u_distance}
variable latticeconst_converted equal 2.938573218882084*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  2.93857321888208
Lattice spacing in x,y,z = 2.9385732 2.9385732 2.9385732
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 (29.385732 29.385732 29.385732)
  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 (29.385732 29.385732 29.385732)
  create_atoms CPU = 0.002 seconds

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

kim_interactions Cr

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

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


mass          1 ${mass_converted}
mass          1 51.9961

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 25375.2043761954 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 313.15*${_u_temperature}
variable temp_converted equal 313.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 313.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 313.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 313.15 313.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  "313.15 - 0.2"
variable      T_up  equal  "313.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.196 | 4.196 | 4.196 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -6964.5054   -6964.5054   -7045.4205   -7045.4205       313.15       313.15    25375.204    25375.204    3405.9935    3405.9935 
    1000    -7058.131    -7058.131   -7137.9441   -7137.9441    308.88461    308.88461    24092.842    24092.842    1143.5637    1143.5637 
Loop time of 30.1226 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.868 ns/day, 8.367 hours/ns, 33.198 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    | 29.388     | 29.388     | 29.388     |   0.0 | 97.56
Neigh   | 0.1891     | 0.1891     | 0.1891     |   0.0 |  0.63
Comm    | 0.12933    | 0.12933    | 0.12933    |   0.0 |  0.43
Output  | 0.00019648 | 0.00019648 | 0.00019648 |   0.0 |  0.00
Modify  | 0.35306    | 0.35306    | 0.35306    |   0.0 |  1.17
Other   |            | 0.06305    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5231.00 ave        5231 max        5231 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      307040.0 ave      307040 max      307040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 307040
Ave neighs/atom = 153.52000
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000    -7058.131    -7058.131   -7137.9441   -7137.9441    308.88461    308.88461    24092.842    24092.842    1143.5637    1143.5637 
    2000   -7110.2392   -7110.2392   -7189.5797   -7189.5797     307.0558     307.0558    23517.244    23517.244    1295.2639    1295.2639 
Loop time of 30.9868 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.788 ns/day, 8.607 hours/ns, 32.272 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    | 30.251     | 30.251     | 30.251     |   0.0 | 97.63
Neigh   | 0.19676    | 0.19676    | 0.19676    |   0.0 |  0.63
Comm    | 0.12538    | 0.12538    | 0.12538    |   0.0 |  0.40
Output  | 0.00023007 | 0.00023007 | 0.00023007 |   0.0 |  0.00
Modify  | 0.35186    | 0.35186    | 0.35186    |   0.0 |  1.14
Other   |            | 0.06135    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5192.00 ave        5192 max        5192 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312866.0 ave      312866 max      312866 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312866
Ave neighs/atom = 156.43300
Neighbor list builds = 4
Dangerous builds = 0
if "${V_metal}>${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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -7110.2392   -7110.2392   -7189.5797   -7189.5797     307.0558     307.0558    23517.244    23517.244    1295.2639    1295.2639 
    3000   -7119.6821   -7119.6821   -7200.6836   -7200.6836    313.48408    313.48408    23534.735    23534.735   -1341.4208   -1341.4208 
Loop time of 31.0399 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.784 ns/day, 8.622 hours/ns, 32.217 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    | 30.363     | 30.363     | 30.363     |   0.0 | 97.82
Neigh   | 0.13936    | 0.13936    | 0.13936    |   0.0 |  0.45
Comm    | 0.12439    | 0.12439    | 0.12439    |   0.0 |  0.40
Output  | 0.00018836 | 0.00018836 | 0.00018836 |   0.0 |  0.00
Modify  | 0.35145    | 0.35145    | 0.35145    |   0.0 |  1.13
Other   |            | 0.06199    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5165.00 ave        5165 max        5165 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311922.0 ave      311922 max      311922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311922
Ave neighs/atom = 155.96100
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -7119.6821   -7119.6821   -7200.6836   -7200.6836    313.48408    313.48408    23534.735    23534.735   -1341.4208   -1341.4208 
    4000   -7118.8223   -7118.8223   -7197.8178   -7197.8178    305.72063    305.72063    23490.974    23490.974    138.47269    138.47269 
Loop time of 30.44 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.838 ns/day, 8.456 hours/ns, 32.851 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.859     | 29.859     | 29.859     |   0.0 | 98.09
Neigh   | 0.046373   | 0.046373   | 0.046373   |   0.0 |  0.15
Comm    | 0.1227     | 0.1227     | 0.1227     |   0.0 |  0.40
Output  | 0.00018856 | 0.00018856 | 0.00018856 |   0.0 |  0.00
Modify  | 0.34929    | 0.34929    | 0.34929    |   0.0 |  1.15
Other   |            | 0.06224    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5189.00 ave        5189 max        5189 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311596.0 ave      311596 max      311596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311596
Ave neighs/atom = 155.79800
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -7118.8223   -7118.8223   -7197.8178   -7197.8178    305.72063    305.72063    23490.974    23490.974    138.47269    138.47269 
    5000    -7118.528    -7118.528   -7200.0919   -7200.0919    315.66063    315.66063    23523.512    23523.512   -2048.5846   -2048.5846 
Loop time of 30.7506 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.810 ns/day, 8.542 hours/ns, 32.520 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    | 30.206     | 30.206     | 30.206     |   0.0 | 98.23
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1237     | 0.1237     | 0.1237     |   0.0 |  0.40
Output  | 0.0001527  | 0.0001527  | 0.0001527  |   0.0 |  0.00
Modify  | 0.35709    | 0.35709    | 0.35709    |   0.0 |  1.16
Other   |            | 0.06355    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5174.00 ave        5174 max        5174 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311458.0 ave      311458 max      311458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311458
Ave neighs/atom = 155.72900
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 = 312.802749753829, Press = 924.81691955286
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000    -7118.528    -7118.528   -7200.0919   -7200.0919    315.66063    315.66063    23523.512    23523.512   -2048.5846   -2048.5846 
    6000   -7118.6232   -7118.6232   -7199.7969   -7199.7969    314.15096    314.15096     23526.48     23526.48    744.64388    744.64388 
Loop time of 30.718 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.813 ns/day, 8.533 hours/ns, 32.554 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    | 30.162     | 30.162     | 30.162     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12322    | 0.12322    | 0.12322    |   0.0 |  0.40
Output  | 0.00015953 | 0.00015953 | 0.00015953 |   0.0 |  0.00
Modify  | 0.36984    | 0.36984    | 0.36984    |   0.0 |  1.20
Other   |            | 0.06299    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5179.00 ave        5179 max        5179 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      310634.0 ave      310634 max      310634 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310634
Ave neighs/atom = 155.31700
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 = 312.476973967015, Press = 46.8884420958551
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -7118.6232   -7118.6232   -7199.7969   -7199.7969    314.15096    314.15096     23526.48     23526.48    744.64388    744.64388 
    7000   -7120.1271   -7120.1271    -7200.123    -7200.123    309.59213    309.59213    23526.775    23526.775   -290.43988   -290.43988 
Loop time of 31.0294 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.784 ns/day, 8.619 hours/ns, 32.228 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    | 30.469     | 30.469     | 30.469     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12342    | 0.12342    | 0.12342    |   0.0 |  0.40
Output  | 0.00015361 | 0.00015361 | 0.00015361 |   0.0 |  0.00
Modify  | 0.37464    | 0.37464    | 0.37464    |   0.0 |  1.21
Other   |            | 0.06169    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5164.00 ave        5164 max        5164 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311344.0 ave      311344 max      311344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311344
Ave neighs/atom = 155.67200
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 = 311.997967734794, Press = 7.63037346230394
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -7120.1271   -7120.1271    -7200.123    -7200.123    309.59213    309.59213    23526.775    23526.775   -290.43988   -290.43988 
    8000   -7119.5648   -7119.5648   -7199.6577   -7199.6577    309.96788    309.96788     23470.77     23470.77    3544.7267    3544.7267 
Loop time of 30.8824 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.798 ns/day, 8.578 hours/ns, 32.381 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    | 30.327     | 30.327     | 30.327     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12239    | 0.12239    | 0.12239    |   0.0 |  0.40
Output  | 0.00015138 | 0.00015138 | 0.00015138 |   0.0 |  0.00
Modify  | 0.37121    | 0.37121    | 0.37121    |   0.0 |  1.20
Other   |            | 0.06202    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5160.00 ave        5160 max        5160 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311260.0 ave      311260 max      311260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311260
Ave neighs/atom = 155.63000
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 = 311.230427307913, Press = 5.35898268236321
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -7119.5648   -7119.5648   -7199.6577   -7199.6577    309.96788    309.96788     23470.77     23470.77    3544.7267    3544.7267 
    9000   -7118.0697   -7118.0697   -7197.6433   -7197.6433     307.9579     307.9579    23477.921    23477.921    2537.3535    2537.3535 
Loop time of 30.1334 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.867 ns/day, 8.370 hours/ns, 33.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    | 29.585     | 29.585     | 29.585     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12133    | 0.12133    | 0.12133    |   0.0 |  0.40
Output  | 0.00019507 | 0.00019507 | 0.00019507 |   0.0 |  0.00
Modify  | 0.36544    | 0.36544    | 0.36544    |   0.0 |  1.21
Other   |            | 0.06143    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5168.00 ave        5168 max        5168 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311942.0 ave      311942 max      311942 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311942
Ave neighs/atom = 155.97100
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 = 311.844576407248, Press = 16.7598254669119
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -7118.0697   -7118.0697   -7197.6433   -7197.6433     307.9579     307.9579    23477.921    23477.921    2537.3535    2537.3535 
   10000   -7116.3561   -7116.3561   -7198.1134   -7198.1134     316.4093     316.4093     23531.66     23531.66   -1464.2078   -1464.2078 
Loop time of 30.5871 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.825 ns/day, 8.496 hours/ns, 32.694 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    | 30.036     | 30.036     | 30.036     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1215     | 0.1215     | 0.1215     |   0.0 |  0.40
Output  | 0.00015506 | 0.00015506 | 0.00015506 |   0.0 |  0.00
Modify  | 0.36721    | 0.36721    | 0.36721    |   0.0 |  1.20
Other   |            | 0.06187    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5170.00 ave        5170 max        5170 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311754.0 ave      311754 max      311754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311754
Ave neighs/atom = 155.87700
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 = 312.287188786753, Press = 19.189188741191
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -7116.3561   -7116.3561   -7198.1134   -7198.1134     316.4093     316.4093     23531.66     23531.66   -1464.2078   -1464.2078 
   11000   -7121.1321   -7121.1321   -7201.1204   -7201.1204    309.56307    309.56307    23527.357    23527.357   -1896.6782   -1896.6782 
Loop time of 30.4766 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.835 ns/day, 8.466 hours/ns, 32.812 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    | 29.922     | 29.922     | 29.922     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12222    | 0.12222    | 0.12222    |   0.0 |  0.40
Output  | 0.00015508 | 0.00015508 | 0.00015508 |   0.0 |  0.00
Modify  | 0.36993    | 0.36993    | 0.36993    |   0.0 |  1.21
Other   |            | 0.06212    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5152.00 ave        5152 max        5152 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      310968.0 ave      310968 max      310968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310968
Ave neighs/atom = 155.48400
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 = 312.772615516307, Press = 17.3951163148254
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -7121.1321   -7121.1321   -7201.1204   -7201.1204    309.56307    309.56307    23527.357    23527.357   -1896.6782   -1896.6782 
   12000   -7115.9409   -7115.9409   -7199.3486   -7199.3486    322.79655    322.79655    23546.967    23546.967   -2182.3851   -2182.3851 
Loop time of 30.4887 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.834 ns/day, 8.469 hours/ns, 32.799 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    | 29.934     | 29.934     | 29.934     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12238    | 0.12238    | 0.12238    |   0.0 |  0.40
Output  | 0.00015185 | 0.00015185 | 0.00015185 |   0.0 |  0.00
Modify  | 0.37041    | 0.37041    | 0.37041    |   0.0 |  1.21
Other   |            | 0.06199    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5174.00 ave        5174 max        5174 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311464.0 ave      311464 max      311464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311464
Ave neighs/atom = 155.73200
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 = 313.106308521378, Press = 16.1841366107097
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -7115.9409   -7115.9409   -7199.3486   -7199.3486    322.79655    322.79655    23546.967    23546.967   -2182.3851   -2182.3851 
   13000   -7117.8923   -7117.8923   -7198.2409   -7198.2409    310.95738    310.95738     23556.82     23556.82   -3089.8611   -3089.8611 
Loop time of 30.6933 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.815 ns/day, 8.526 hours/ns, 32.580 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    | 30.131     | 30.131     | 30.131     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12302    | 0.12302    | 0.12302    |   0.0 |  0.40
Output  | 0.00015397 | 0.00015397 | 0.00015397 |   0.0 |  0.00
Modify  | 0.3765     | 0.3765     | 0.3765     |   0.0 |  1.23
Other   |            | 0.06246    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5150.00 ave        5150 max        5150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      310978.0 ave      310978 max      310978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310978
Ave neighs/atom = 155.48900
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 = 313.275163134591, Press = 8.96887824721899
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -7117.8923   -7117.8923   -7198.2409   -7198.2409    310.95738    310.95738     23556.82     23556.82   -3089.8611   -3089.8611 
   14000    -7118.539    -7118.539   -7200.1101   -7200.1101    315.68864    315.68864    23539.776    23539.776   -2602.6874   -2602.6874 
Loop time of 30.2803 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.853 ns/day, 8.411 hours/ns, 33.025 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    | 29.729     | 29.729     | 29.729     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12202    | 0.12202    | 0.12202    |   0.0 |  0.40
Output  | 0.00015612 | 0.00015612 | 0.00015612 |   0.0 |  0.00
Modify  | 0.36663    | 0.36663    | 0.36663    |   0.0 |  1.21
Other   |            | 0.06249    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5154.00 ave        5154 max        5154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      310832.0 ave      310832 max      310832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310832
Ave neighs/atom = 155.41600
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 = 313.466694625699, Press = 3.43560451981038
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000    -7118.539    -7118.539   -7200.1101   -7200.1101    315.68864    315.68864    23539.776    23539.776   -2602.6874   -2602.6874 
   15000   -7118.5802   -7118.5802   -7200.1096   -7200.1096    315.52728    315.52728    23564.142    23564.142   -2994.2342   -2994.2342 
Loop time of 30.7718 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.808 ns/day, 8.548 hours/ns, 32.497 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    | 30.21      | 30.21      | 30.21      |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12314    | 0.12314    | 0.12314    |   0.0 |  0.40
Output  | 0.00020572 | 0.00020572 | 0.00020572 |   0.0 |  0.00
Modify  | 0.37535    | 0.37535    | 0.37535    |   0.0 |  1.22
Other   |            | 0.06272    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5156.00 ave        5156 max        5156 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311268.0 ave      311268 max      311268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311268
Ave neighs/atom = 155.63400
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 = 313.36889921419, Press = 4.44244140989176
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -7118.5802   -7118.5802   -7200.1096   -7200.1096    315.52728    315.52728    23564.142    23564.142   -2994.2342   -2994.2342 
   16000   -7115.4035   -7115.4035   -7196.2588   -7196.2588    312.91844    312.91844    23511.251    23511.251   -350.10882   -350.10882 
Loop time of 30.8821 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.798 ns/day, 8.578 hours/ns, 32.381 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    | 30.32      | 30.32      | 30.32      |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12391    | 0.12391    | 0.12391    |   0.0 |  0.40
Output  | 0.00020238 | 0.00020238 | 0.00020238 |   0.0 |  0.00
Modify  | 0.37552    | 0.37552    | 0.37552    |   0.0 |  1.22
Other   |            | 0.06257    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5168.00 ave        5168 max        5168 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      310932.0 ave      310932 max      310932 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310932
Ave neighs/atom = 155.46600
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 = 313.639851842152, Press = 0.0372229594371232
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -7115.4035   -7115.4035   -7196.2588   -7196.2588    312.91844    312.91844    23511.251    23511.251   -350.10882   -350.10882 
   17000   -7120.0398   -7120.0398   -7200.2109   -7200.2109    310.27021    310.27021    23488.733    23488.733    1553.3238    1553.3238 
Loop time of 30.5463 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.828 ns/day, 8.485 hours/ns, 32.737 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.989     | 29.989     | 29.989     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12308    | 0.12308    | 0.12308    |   0.0 |  0.40
Output  | 0.00019685 | 0.00019685 | 0.00019685 |   0.0 |  0.00
Modify  | 0.37161    | 0.37161    | 0.37161    |   0.0 |  1.22
Other   |            | 0.06242    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5165.00 ave        5165 max        5165 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311362.0 ave      311362 max      311362 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311362
Ave neighs/atom = 155.68100
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 = 313.725661025213, Press = 2.86613252784613
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -7120.0398   -7120.0398   -7200.2109   -7200.2109    310.27021    310.27021    23488.733    23488.733    1553.3238    1553.3238 
   18000   -7118.0936   -7118.0936   -7199.9803   -7199.9803    316.91013    316.91013    23513.826    23513.826   -524.53516   -524.53516 
Loop time of 30.0949 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.871 ns/day, 8.360 hours/ns, 33.228 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    | 29.548     | 29.548     | 29.548     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12002    | 0.12002    | 0.12002    |   0.0 |  0.40
Output  | 0.0001506  | 0.0001506  | 0.0001506  |   0.0 |  0.00
Modify  | 0.36542    | 0.36542    | 0.36542    |   0.0 |  1.21
Other   |            | 0.06141    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5146.00 ave        5146 max        5146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312078.0 ave      312078 max      312078 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312078
Ave neighs/atom = 156.03900
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 = 313.753698294402, Press = 4.37001042869844
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -7118.0936   -7118.0936   -7199.9803   -7199.9803    316.91013    316.91013    23513.826    23513.826   -524.53516   -524.53516 
   19000    -7120.131    -7120.131   -7201.7432   -7201.7432    315.84792    315.84792    23521.502    23521.502   -297.74382   -297.74382 
Loop time of 29.8958 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.890 ns/day, 8.304 hours/ns, 33.450 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.35      | 29.35      | 29.35      |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1199     | 0.1199     | 0.1199     |   0.0 |  0.40
Output  | 0.00015291 | 0.00015291 | 0.00015291 |   0.0 |  0.00
Modify  | 0.36376    | 0.36376    | 0.36376    |   0.0 |  1.22
Other   |            | 0.06192    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5161.00 ave        5161 max        5161 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311338.0 ave      311338 max      311338 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311338
Ave neighs/atom = 155.66900
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 = 313.718826142059, Press = 1.1789582840233
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000    -7120.131    -7120.131   -7201.7432   -7201.7432    315.84792    315.84792    23521.502    23521.502   -297.74382   -297.74382 
   20000   -7116.6489   -7116.6489    -7196.009    -7196.009    307.13144    307.13144     23497.75     23497.75      1901.08      1901.08 
Loop time of 30.5922 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.824 ns/day, 8.498 hours/ns, 32.688 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    | 30.035     | 30.035     | 30.035     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12294    | 0.12294    | 0.12294    |   0.0 |  0.40
Output  | 0.00015522 | 0.00015522 | 0.00015522 |   0.0 |  0.00
Modify  | 0.37128    | 0.37128    | 0.37128    |   0.0 |  1.21
Other   |            | 0.06253    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5168.00 ave        5168 max        5168 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311458.0 ave      311458 max      311458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311458
Ave neighs/atom = 155.72900
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 = 313.67918458598, Press = 8.96295603141655
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -7116.6489   -7116.6489    -7196.009    -7196.009    307.13144    307.13144     23497.75     23497.75      1901.08      1901.08 
   21000   -7125.8203   -7125.8203   -7205.2028   -7205.2028    307.21832    307.21832    23539.301    23539.301   -2488.5143   -2488.5143 
Loop time of 30.4141 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.841 ns/day, 8.448 hours/ns, 32.879 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.86      | 29.86      | 29.86      |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12269    | 0.12269    | 0.12269    |   0.0 |  0.40
Output  | 0.00015404 | 0.00015404 | 0.00015404 |   0.0 |  0.00
Modify  | 0.36933    | 0.36933    | 0.36933    |   0.0 |  1.21
Other   |            | 0.06198    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5174.00 ave        5174 max        5174 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311950.0 ave      311950 max      311950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311950
Ave neighs/atom = 155.97500
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 = 313.497429906648, Press = 5.83582059254265
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -7125.8203   -7125.8203   -7205.2028   -7205.2028    307.21832    307.21832    23539.301    23539.301   -2488.5143   -2488.5143 
   22000   -7117.4662   -7117.4662   -7198.6384   -7198.6384    314.14514    314.14514    23521.958    23521.958   -819.92683   -819.92683 
Loop time of 30.2679 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.855 ns/day, 8.408 hours/ns, 33.038 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    | 29.714     | 29.714     | 29.714     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12236    | 0.12236    | 0.12236    |   0.0 |  0.40
Output  | 0.0001971  | 0.0001971  | 0.0001971  |   0.0 |  0.00
Modify  | 0.36857    | 0.36857    | 0.36857    |   0.0 |  1.22
Other   |            | 0.06243    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5160.00 ave        5160 max        5160 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      310922.0 ave      310922 max      310922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310922
Ave neighs/atom = 155.46100
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 = 313.396907342092, Press = 4.07844774561691
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -7117.4662   -7117.4662   -7198.6384   -7198.6384    314.14514    314.14514    23521.958    23521.958   -819.92683   -819.92683 
   23000   -7114.5397   -7114.5397   -7196.0711   -7196.0711    315.53503    315.53503    23520.451    23520.451    -468.8848    -468.8848 
Loop time of 31.7131 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.724 ns/day, 8.809 hours/ns, 31.533 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.141     | 31.141     | 31.141     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12561    | 0.12561    | 0.12561    |   0.0 |  0.40
Output  | 0.00015442 | 0.00015442 | 0.00015442 |   0.0 |  0.00
Modify  | 0.3839     | 0.3839     | 0.3839     |   0.0 |  1.21
Other   |            | 0.06236    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5150.00 ave        5150 max        5150 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311332.0 ave      311332 max      311332 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311332
Ave neighs/atom = 155.66600
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 = 313.415779338593, Press = 2.18552417940226
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -7114.5397   -7114.5397   -7196.0711   -7196.0711    315.53503    315.53503    23520.451    23520.451    -468.8848    -468.8848 
   24000   -7119.0855   -7119.0855   -7200.5958   -7200.5958    315.45326    315.45326    23569.169    23569.169   -4164.9143   -4164.9143 
Loop time of 30.3665 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.845 ns/day, 8.435 hours/ns, 32.931 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    | 29.818     | 29.818     | 29.818     |   0.0 | 98.20
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1205     | 0.1205     | 0.1205     |   0.0 |  0.40
Output  | 0.00015334 | 0.00015334 | 0.00015334 |   0.0 |  0.00
Modify  | 0.36578    | 0.36578    | 0.36578    |   0.0 |  1.20
Other   |            | 0.06168    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5154.00 ave        5154 max        5154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311284.0 ave      311284 max      311284 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311284
Ave neighs/atom = 155.64200
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 = 313.542529239165, Press = 4.16658394020261
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -7119.0855   -7119.0855   -7200.5958   -7200.5958    315.45326    315.45326    23569.169    23569.169   -4164.9143   -4164.9143 
   25000    -7114.555    -7114.555   -7196.7725   -7196.7725     318.1902     318.1902    23553.065    23553.065   -2397.8171   -2397.8171 
Loop time of 30.6029 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.823 ns/day, 8.501 hours/ns, 32.677 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    | 30.05      | 30.05      | 30.05      |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12135    | 0.12135    | 0.12135    |   0.0 |  0.40
Output  | 0.0001582  | 0.0001582  | 0.0001582  |   0.0 |  0.00
Modify  | 0.36959    | 0.36959    | 0.36959    |   0.0 |  1.21
Other   |            | 0.06177    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5147.00 ave        5147 max        5147 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      310912.0 ave      310912 max      310912 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310912
Ave neighs/atom = 155.45600
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 = 313.632735208599, Press = 1.56969056076472
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000    -7114.555    -7114.555   -7196.7725   -7196.7725     318.1902     318.1902    23553.065    23553.065   -2397.8171   -2397.8171 
   26000   -7119.1628   -7119.1628   -7200.8824   -7200.8824    316.26333    316.26333    23517.146    23517.146   -989.84562   -989.84562 
Loop time of 31.2743 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.763 ns/day, 8.687 hours/ns, 31.975 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    | 30.709     | 30.709     | 30.709     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12429    | 0.12429    | 0.12429    |   0.0 |  0.40
Output  | 0.00015412 | 0.00015412 | 0.00015412 |   0.0 |  0.00
Modify  | 0.37886    | 0.37886    | 0.37886    |   0.0 |  1.21
Other   |            | 0.06233    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5163.00 ave        5163 max        5163 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      310852.0 ave      310852 max      310852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310852
Ave neighs/atom = 155.42600
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 = 313.659017622548, Press = 4.2839734817081
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -7119.1628   -7119.1628   -7200.8824   -7200.8824    316.26333    316.26333    23517.146    23517.146   -989.84562   -989.84562 
   27000   -7118.5157   -7118.5157   -7200.3264   -7200.3264    316.61584    316.61584    23535.533    23535.533   -2032.5735   -2032.5735 
Loop time of 31.1733 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.772 ns/day, 8.659 hours/ns, 32.079 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.609     | 30.609     | 30.609     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12332    | 0.12332    | 0.12332    |   0.0 |  0.40
Output  | 0.00015412 | 0.00015412 | 0.00015412 |   0.0 |  0.00
Modify  | 0.37788    | 0.37788    | 0.37788    |   0.0 |  1.21
Other   |            | 0.06248    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5154.00 ave        5154 max        5154 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311294.0 ave      311294 max      311294 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311294
Ave neighs/atom = 155.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 = 313.626309679725, Press = 1.84431793247535
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -7118.5157   -7118.5157   -7200.3264   -7200.3264    316.61584    316.61584    23535.533    23535.533   -2032.5735   -2032.5735 
   28000   -7117.7678   -7117.7678   -7197.4991   -7197.4991    308.56846    308.56846    23528.192    23528.192   -1456.8152   -1456.8152 
Loop time of 29.8848 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.891 ns/day, 8.301 hours/ns, 33.462 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.335     | 29.335     | 29.335     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1223     | 0.1223     | 0.1223     |   0.0 |  0.41
Output  | 0.00015278 | 0.00015278 | 0.00015278 |   0.0 |  0.00
Modify  | 0.3652     | 0.3652     | 0.3652     |   0.0 |  1.22
Other   |            | 0.06203    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5174.00 ave        5174 max        5174 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311144.0 ave      311144 max      311144 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311144
Ave neighs/atom = 155.57200
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 = 313.518063816749, Press = 2.48714704757552
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -7117.7678   -7117.7678   -7197.4991   -7197.4991    308.56846    308.56846    23528.192    23528.192   -1456.8152   -1456.8152 
   29000   -7119.3308   -7119.3308   -7200.4304   -7200.4304    313.86374    313.86374    23493.473    23493.473    1771.7008    1771.7008 
Loop time of 30.5606 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.827 ns/day, 8.489 hours/ns, 32.722 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.003     | 30.003     | 30.003     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12248    | 0.12248    | 0.12248    |   0.0 |  0.40
Output  | 0.00015502 | 0.00015502 | 0.00015502 |   0.0 |  0.00
Modify  | 0.37204    | 0.37204    | 0.37204    |   0.0 |  1.22
Other   |            | 0.06261    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5157.00 ave        5157 max        5157 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311138.0 ave      311138 max      311138 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311138
Ave neighs/atom = 155.56900
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 = 313.552340499898, Press = 1.99861219935717
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -7119.3308   -7119.3308   -7200.4304   -7200.4304    313.86374    313.86374    23493.473    23493.473    1771.7008    1771.7008 
   30000    -7117.672    -7117.672   -7198.0134   -7198.0134    310.92932    310.92932    23562.507    23562.507   -3469.6422   -3469.6422 
Loop time of 29.507 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.928 ns/day, 8.196 hours/ns, 33.890 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    | 28.966     | 28.966     | 28.966     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12003    | 0.12003    | 0.12003    |   0.0 |  0.41
Output  | 0.0001537  | 0.0001537  | 0.0001537  |   0.0 |  0.00
Modify  | 0.35889    | 0.35889    | 0.35889    |   0.0 |  1.22
Other   |            | 0.06189    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5180.00 ave        5180 max        5180 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311818.0 ave      311818 max      311818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311818
Ave neighs/atom = 155.90900
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 = 313.555923452398, Press = 2.62437511895851
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000    -7117.672    -7117.672   -7198.0134   -7198.0134    310.92932    310.92932    23562.507    23562.507   -3469.6422   -3469.6422 
   31000   -7121.3457   -7121.3457   -7201.5625   -7201.5625    310.44702    310.44702    23492.046    23492.046    1472.6643    1472.6643 
Loop time of 30.1487 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.866 ns/day, 8.375 hours/ns, 33.169 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.6       | 29.6       | 29.6       |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12127    | 0.12127    | 0.12127    |   0.0 |  0.40
Output  | 0.00020083 | 0.00020083 | 0.00020083 |   0.0 |  0.00
Modify  | 0.36523    | 0.36523    | 0.36523    |   0.0 |  1.21
Other   |            | 0.06196    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5169.00 ave        5169 max        5169 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      310768.0 ave      310768 max      310768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310768
Ave neighs/atom = 155.38400
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 = 313.525863246274, Press = -0.747445311199694
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -7121.3457   -7121.3457   -7201.5625   -7201.5625    310.44702    310.44702    23492.046    23492.046    1472.6643    1472.6643 
   32000    -7117.463    -7117.463   -7198.5726   -7198.5726    313.90245    313.90245    23502.917    23502.917    849.36194    849.36194 
Loop time of 30.6563 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.818 ns/day, 8.516 hours/ns, 32.620 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.097     | 30.097     | 30.097     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12193    | 0.12193    | 0.12193    |   0.0 |  0.40
Output  | 0.00015693 | 0.00015693 | 0.00015693 |   0.0 |  0.00
Modify  | 0.37569    | 0.37569    | 0.37569    |   0.0 |  1.23
Other   |            | 0.0618     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5145.00 ave        5145 max        5145 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311584.0 ave      311584 max      311584 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311584
Ave neighs/atom = 155.79200
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 = 313.441746018078, Press = 2.28843135129686
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000    -7117.463    -7117.463   -7198.5726   -7198.5726    313.90245    313.90245    23502.917    23502.917    849.36194    849.36194 
   33000   -7120.2594   -7120.2594   -7198.1569   -7198.1569    301.47118    301.47118    23473.816    23473.816    2368.1897    2368.1897 
Loop time of 29.9977 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.880 ns/day, 8.333 hours/ns, 33.336 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    | 29.447     | 29.447     | 29.447     |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12251    | 0.12251    | 0.12251    |   0.0 |  0.41
Output  | 0.00015529 | 0.00015529 | 0.00015529 |   0.0 |  0.00
Modify  | 0.3655     | 0.3655     | 0.3655     |   0.0 |  1.22
Other   |            | 0.06261    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5172.00 ave        5172 max        5172 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311386.0 ave      311386 max      311386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311386
Ave neighs/atom = 155.69300
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 = 313.397711098249, Press = 0.285373232572427
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -7120.2594   -7120.2594   -7198.1569   -7198.1569    301.47118    301.47118    23473.816    23473.816    2368.1897    2368.1897 
   34000   -7114.5737   -7114.5737   -7196.4147   -7196.4147    316.73318    316.73318    23505.023    23505.023    696.47941    696.47941 
Loop time of 30.9915 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.788 ns/day, 8.609 hours/ns, 32.267 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    | 30.429     | 30.429     | 30.429     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12335    | 0.12335    | 0.12335    |   0.0 |  0.40
Output  | 0.0002458  | 0.0002458  | 0.0002458  |   0.0 |  0.00
Modify  | 0.37607    | 0.37607    | 0.37607    |   0.0 |  1.21
Other   |            | 0.06267    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5163.00 ave        5163 max        5163 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311936.0 ave      311936 max      311936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311936
Ave neighs/atom = 155.96800
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 = 313.417555285834, Press = 1.13509147247564
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -7114.5737   -7114.5737   -7196.4147   -7196.4147    316.73318    316.73318    23505.023    23505.023    696.47941    696.47941 
   35000    -7119.175    -7119.175     -7199.69     -7199.69    311.60141    311.60141     23480.68     23480.68    2682.2124    2682.2124 
Loop time of 31.5295 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.740 ns/day, 8.758 hours/ns, 31.716 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.956     | 30.956     | 30.956     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12625    | 0.12625    | 0.12625    |   0.0 |  0.40
Output  | 0.00015453 | 0.00015453 | 0.00015453 |   0.0 |  0.00
Modify  | 0.38462    | 0.38462    | 0.38462    |   0.0 |  1.22
Other   |            | 0.0628     |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5161.00 ave        5161 max        5161 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311366.0 ave      311366 max      311366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311366
Ave neighs/atom = 155.68300
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 = 313.467692480176, Press = 1.93061022039071
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000    -7119.175    -7119.175     -7199.69     -7199.69    311.60141    311.60141     23480.68     23480.68    2682.2124    2682.2124 
   36000   -7119.5037   -7119.5037   -7200.0972   -7200.0972    311.90539    311.90539    23520.372    23520.372    44.906388    44.906388 
Loop time of 30.1311 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.867 ns/day, 8.370 hours/ns, 33.188 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    | 29.581     | 29.581     | 29.581     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12185    | 0.12185    | 0.12185    |   0.0 |  0.40
Output  | 0.00015544 | 0.00015544 | 0.00015544 |   0.0 |  0.00
Modify  | 0.3668     | 0.3668     | 0.3668     |   0.0 |  1.22
Other   |            | 0.06179    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5172.00 ave        5172 max        5172 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312148.0 ave      312148 max      312148 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312148
Ave neighs/atom = 156.07400
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 = 313.489053680913, Press = 1.58082209259542
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -7119.5037   -7119.5037   -7200.0972   -7200.0972    311.90539    311.90539    23520.372    23520.372    44.906388    44.906388 
   37000   -7118.5664   -7118.5664   -7199.4557   -7199.4557    313.05001    313.05001    23495.669    23495.669    1131.6479    1131.6479 
Loop time of 30.2961 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.852 ns/day, 8.416 hours/ns, 33.008 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    | 29.744     | 29.744     | 29.744     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12244    | 0.12244    | 0.12244    |   0.0 |  0.40
Output  | 0.00015453 | 0.00015453 | 0.00015453 |   0.0 |  0.00
Modify  | 0.3678     | 0.3678     | 0.3678     |   0.0 |  1.21
Other   |            | 0.06165    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5156.00 ave        5156 max        5156 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311270.0 ave      311270 max      311270 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311270
Ave neighs/atom = 155.63500
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 = 313.420681701057, Press = 3.77740992524739
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -7118.5664   -7118.5664   -7199.4557   -7199.4557    313.05001    313.05001    23495.669    23495.669    1131.6479    1131.6479 
   38000   -7122.6149   -7122.6149   -7201.8421   -7201.8421    306.61747    306.61747    23526.369    23526.369   -2134.4161   -2134.4161 
Loop time of 31.0756 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.780 ns/day, 8.632 hours/ns, 32.180 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    | 30.515     | 30.515     | 30.515     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12428    | 0.12428    | 0.12428    |   0.0 |  0.40
Output  | 0.00015323 | 0.00015323 | 0.00015323 |   0.0 |  0.00
Modify  | 0.37403    | 0.37403    | 0.37403    |   0.0 |  1.20
Other   |            | 0.06265    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5171.00 ave        5171 max        5171 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311714.0 ave      311714 max      311714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311714
Ave neighs/atom = 155.85700
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 = 313.368387578489, Press = 0.275592610218064
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -7122.6149   -7122.6149   -7201.8421   -7201.8421    306.61747    306.61747    23526.369    23526.369   -2134.4161   -2134.4161 
   39000   -7116.2097   -7116.2097   -7199.4449   -7199.4449    322.12864    322.12864    23486.429    23486.429    1727.4794    1727.4794 
Loop time of 31.205 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.769 ns/day, 8.668 hours/ns, 32.046 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    | 30.638     | 30.638     | 30.638     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12437    | 0.12437    | 0.12437    |   0.0 |  0.40
Output  | 0.00019789 | 0.00019789 | 0.00019789 |   0.0 |  0.00
Modify  | 0.38002    | 0.38002    | 0.38002    |   0.0 |  1.22
Other   |            | 0.06233    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5146.00 ave        5146 max        5146 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311310.0 ave      311310 max      311310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311310
Ave neighs/atom = 155.65500
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 = 313.303425722783, Press = 1.20291317705592
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -7116.2097   -7116.2097   -7199.4449   -7199.4449    322.12864    322.12864    23486.429    23486.429    1727.4794    1727.4794 
   40000   -7119.6336   -7119.6336      -7198.5      -7198.5    305.22109    305.22109     23521.65     23521.65   -726.11446   -726.11446 
Loop time of 30.462 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.836 ns/day, 8.462 hours/ns, 32.828 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.905     | 29.905     | 29.905     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12201    | 0.12201    | 0.12201    |   0.0 |  0.40
Output  | 0.00015128 | 0.00015128 | 0.00015128 |   0.0 |  0.00
Modify  | 0.37228    | 0.37228    | 0.37228    |   0.0 |  1.22
Other   |            | 0.06246    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5148.00 ave        5148 max        5148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311834.0 ave      311834 max      311834 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311834
Ave neighs/atom = 155.91700
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 = 313.311708263312, Press = -0.304865827530716
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -7119.6336   -7119.6336      -7198.5      -7198.5    305.22109    305.22109     23521.65     23521.65   -726.11446   -726.11446 
   41000   -7120.3481   -7120.3481   -7198.6988   -7198.6988    303.22518    303.22518    23480.112    23480.112    3201.2133    3201.2133 
Loop time of 30.564 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.827 ns/day, 8.490 hours/ns, 32.718 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 30.009     | 30.009     | 30.009     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12366    | 0.12366    | 0.12366    |   0.0 |  0.40
Output  | 0.00015229 | 0.00015229 | 0.00015229 |   0.0 |  0.00
Modify  | 0.36985    | 0.36985    | 0.36985    |   0.0 |  1.21
Other   |            | 0.06182    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5166.00 ave        5166 max        5166 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311398.0 ave      311398 max      311398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311398
Ave neighs/atom = 155.69900
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 = 313.226651050212, Press = 1.62685179049391
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -7120.3481   -7120.3481   -7198.6988   -7198.6988    303.22518    303.22518    23480.112    23480.112    3201.2133    3201.2133 
   42000   -7119.1194   -7119.1194   -7200.8514   -7200.8514    316.31136    316.31136     23481.37     23481.37    2158.3798    2158.3798 
Loop time of 30.1267 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.868 ns/day, 8.369 hours/ns, 33.193 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    | 29.575     | 29.575     | 29.575     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12289    | 0.12289    | 0.12289    |   0.0 |  0.41
Output  | 0.0001554  | 0.0001554  | 0.0001554  |   0.0 |  0.00
Modify  | 0.36682    | 0.36682    | 0.36682    |   0.0 |  1.22
Other   |            | 0.06181    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5168.00 ave        5168 max        5168 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311666.0 ave      311666 max      311666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311666
Ave neighs/atom = 155.83300
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 = 313.213075805478, Press = 3.34540412271039
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -7119.1194   -7119.1194   -7200.8514   -7200.8514    316.31136    316.31136     23481.37     23481.37    2158.3798    2158.3798 
   43000    -7113.688    -7113.688   -7198.3019   -7198.3019    327.46464    327.46464    23505.499    23505.499    1120.2046    1120.2046 
Loop time of 30.3507 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.847 ns/day, 8.431 hours/ns, 32.948 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.8       | 29.8       | 29.8       |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12246    | 0.12246    | 0.12246    |   0.0 |  0.40
Output  | 0.00019059 | 0.00019059 | 0.00019059 |   0.0 |  0.00
Modify  | 0.36594    | 0.36594    | 0.36594    |   0.0 |  1.21
Other   |            | 0.06219    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5166.00 ave        5166 max        5166 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311772.0 ave      311772 max      311772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311772
Ave neighs/atom = 155.88600
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 = 313.221929399844, Press = 2.32660388567961
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000    -7113.688    -7113.688   -7198.3019   -7198.3019    327.46464    327.46464    23505.499    23505.499    1120.2046    1120.2046 
   44000   -7119.6063   -7119.6063   -7200.7832   -7200.7832    314.16305    314.16305    23514.819    23514.819    585.84412    585.84412 
Loop time of 30.5491 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.828 ns/day, 8.486 hours/ns, 32.734 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.992     | 29.992     | 29.992     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12317    | 0.12317    | 0.12317    |   0.0 |  0.40
Output  | 0.00019293 | 0.00019293 | 0.00019293 |   0.0 |  0.00
Modify  | 0.37087    | 0.37087    | 0.37087    |   0.0 |  1.21
Other   |            | 0.06295    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5159.00 ave        5159 max        5159 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311772.0 ave      311772 max      311772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311772
Ave neighs/atom = 155.88600
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 = 313.267838257797, Press = 4.05510684663041
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -7119.6063   -7119.6063   -7200.7832   -7200.7832    314.16305    314.16305    23514.819    23514.819    585.84412    585.84412 
   45000   -7118.3442   -7118.3442   -7197.9391   -7197.9391    308.04061    308.04061     23534.62     23534.62    -1670.248    -1670.248 
Loop time of 30.5112 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.832 ns/day, 8.475 hours/ns, 32.775 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.958     | 29.958     | 29.958     |   0.0 | 98.19
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1219     | 0.1219     | 0.1219     |   0.0 |  0.40
Output  | 0.00015479 | 0.00015479 | 0.00015479 |   0.0 |  0.00
Modify  | 0.36843    | 0.36843    | 0.36843    |   0.0 |  1.21
Other   |            | 0.06227    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5161.00 ave        5161 max        5161 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311264.0 ave      311264 max      311264 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311264
Ave neighs/atom = 155.63200
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 = 313.321740866767, Press = 1.17117249818852
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -7118.3442   -7118.3442   -7197.9391   -7197.9391    308.04061    308.04061     23534.62     23534.62    -1670.248    -1670.248 
   46000   -7117.0088   -7117.0088   -7198.4772   -7198.4772    315.29123    315.29123    23513.952    23513.952   -156.05744   -156.05744 
Loop time of 30.3595 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.846 ns/day, 8.433 hours/ns, 32.939 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    | 29.803     | 29.803     | 29.803     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12271    | 0.12271    | 0.12271    |   0.0 |  0.40
Output  | 0.00015508 | 0.00015508 | 0.00015508 |   0.0 |  0.00
Modify  | 0.3711     | 0.3711     | 0.3711     |   0.0 |  1.22
Other   |            | 0.06283    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5187.00 ave        5187 max        5187 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311326.0 ave      311326 max      311326 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311326
Ave neighs/atom = 155.66300
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 = 313.293399240054, Press = 1.98263467240809
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -7117.0088   -7117.0088   -7198.4772   -7198.4772    315.29123    315.29123    23513.952    23513.952   -156.05744   -156.05744 
   47000   -7123.3912   -7123.3912   -7202.3113   -7202.3113     305.4292     305.4292    23537.499    23537.499   -2185.0479   -2185.0479 
Loop time of 30.1779 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.863 ns/day, 8.383 hours/ns, 33.137 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    | 29.628     | 29.628     | 29.628     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12141    | 0.12141    | 0.12141    |   0.0 |  0.40
Output  | 0.00015769 | 0.00015769 | 0.00015769 |   0.0 |  0.00
Modify  | 0.36575    | 0.36575    | 0.36575    |   0.0 |  1.21
Other   |            | 0.06229    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5162.00 ave        5162 max        5162 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311510.0 ave      311510 max      311510 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311510
Ave neighs/atom = 155.75500
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 = 313.236932289856, Press = 1.17898490016523
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -7123.3912   -7123.3912   -7202.3113   -7202.3113     305.4292     305.4292    23537.499    23537.499   -2185.0479   -2185.0479 
   48000   -7118.6958   -7118.6958   -7199.8431   -7199.8431    314.04832    314.04832    23523.966    23523.966   -1073.6746   -1073.6746 
Loop time of 30.0484 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.875 ns/day, 8.347 hours/ns, 33.280 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    | 29.499     | 29.499     | 29.499     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12277    | 0.12277    | 0.12277    |   0.0 |  0.41
Output  | 0.00015397 | 0.00015397 | 0.00015397 |   0.0 |  0.00
Modify  | 0.36408    | 0.36408    | 0.36408    |   0.0 |  1.21
Other   |            | 0.06218    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5177.00 ave        5177 max        5177 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311006.0 ave      311006 max      311006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311006
Ave neighs/atom = 155.50300
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 = 313.207071311122, Press = 0.333855843057288
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -7118.6958   -7118.6958   -7199.8431   -7199.8431    314.04832    314.04832    23523.966    23523.966   -1073.6746   -1073.6746 
   49000   -7120.2093   -7120.2093   -7200.7524   -7200.7524    311.71004    311.71004    23494.611    23494.611    1703.4896    1703.4896 
Loop time of 30.2849 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.853 ns/day, 8.412 hours/ns, 33.020 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.73      | 29.73      | 29.73      |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12357    | 0.12357    | 0.12357    |   0.0 |  0.41
Output  | 0.00015414 | 0.00015414 | 0.00015414 |   0.0 |  0.00
Modify  | 0.36887    | 0.36887    | 0.36887    |   0.0 |  1.22
Other   |            | 0.06265    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5174.00 ave        5174 max        5174 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311458.0 ave      311458 max      311458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311458
Ave neighs/atom = 155.72900
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 = 313.145652984442, Press = 1.37598777412387
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -7120.2093   -7120.2093   -7200.7524   -7200.7524    311.71004    311.71004    23494.611    23494.611    1703.4896    1703.4896 
   50000   -7116.8698   -7116.8698   -7196.7193   -7196.7193    309.02578    309.02578    23483.554    23483.554    2126.1526    2126.1526 
Loop time of 30.2875 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.853 ns/day, 8.413 hours/ns, 33.017 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    | 29.73      | 29.73      | 29.73      |   0.0 | 98.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12431    | 0.12431    | 0.12431    |   0.0 |  0.41
Output  | 0.00015577 | 0.00015577 | 0.00015577 |   0.0 |  0.00
Modify  | 0.37       | 0.37       | 0.37       |   0.0 |  1.22
Other   |            | 0.06261    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5171.00 ave        5171 max        5171 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311592.0 ave      311592 max      311592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311592
Ave neighs/atom = 155.79600
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 = 313.153895652631, Press = 0.57562384748308
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -7116.8698   -7116.8698   -7196.7193   -7196.7193    309.02578    309.02578    23483.554    23483.554    2126.1526    2126.1526 
   51000   -7119.3833   -7119.3833   -7198.7944   -7198.7944    307.32919    307.32919    23444.549    23444.549     4669.649     4669.649 
Loop time of 30.535 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.830 ns/day, 8.482 hours/ns, 32.749 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    | 29.978     | 29.978     | 29.978     |   0.0 | 98.18
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1226     | 0.1226     | 0.1226     |   0.0 |  0.40
Output  | 0.00015463 | 0.00015463 | 0.00015463 |   0.0 |  0.00
Modify  | 0.37199    | 0.37199    | 0.37199    |   0.0 |  1.22
Other   |            | 0.06233    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5157.00 ave        5157 max        5157 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311588.0 ave      311588 max      311588 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311588
Ave neighs/atom = 155.79400
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 = 313.142926456974, Press = 1.81859751069702
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -7119.3833   -7119.3833   -7198.7944   -7198.7944    307.32919    307.32919    23444.549    23444.549     4669.649     4669.649 
   52000   -7117.4964   -7117.4964   -7198.3804   -7198.3804    313.02939    313.02939    23517.624    23517.624   -13.923815   -13.923815 
Loop time of 30.4431 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.838 ns/day, 8.456 hours/ns, 32.848 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    | 29.887     | 29.887     | 29.887     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12326    | 0.12326    | 0.12326    |   0.0 |  0.40
Output  | 0.0001519  | 0.0001519  | 0.0001519  |   0.0 |  0.00
Modify  | 0.37091    | 0.37091    | 0.37091    |   0.0 |  1.22
Other   |            | 0.06232    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5169.00 ave        5169 max        5169 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      312014.0 ave      312014 max      312014 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312014
Ave neighs/atom = 156.00700
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 = 313.20832104678, Press = 3.19884949005238
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -7117.4964   -7117.4964   -7198.3804   -7198.3804    313.02939    313.02939    23517.624    23517.624   -13.923815   -13.923815 
   53000   -7118.8057   -7118.8057   -7200.8461   -7200.8461    317.50489    317.50489    23514.053    23514.053   -626.08604   -626.08604 
Loop time of 29.7574 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.903 ns/day, 8.266 hours/ns, 33.605 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    | 29.213     | 29.213     | 29.213     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12017    | 0.12017    | 0.12017    |   0.0 |  0.40
Output  | 0.00020523 | 0.00020523 | 0.00020523 |   0.0 |  0.00
Modify  | 0.36229    | 0.36229    | 0.36229    |   0.0 |  1.22
Other   |            | 0.06162    |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5143.00 ave        5143 max        5143 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311230.0 ave      311230 max      311230 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311230
Ave neighs/atom = 155.61500
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 = 313.221937893766, Press = 1.5312432870949
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -7118.8057   -7118.8057   -7200.8461   -7200.8461    317.50489    317.50489    23514.053    23514.053   -626.08604   -626.08604 
   54000   -7116.4167   -7116.4167   -7199.2059   -7199.2059    320.40281    320.40281    23503.045    23503.045    1170.1918    1170.1918 
Loop time of 30.207 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.860 ns/day, 8.391 hours/ns, 33.105 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 29.655     | 29.655     | 29.655     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12256    | 0.12256    | 0.12256    |   0.0 |  0.41
Output  | 0.00019429 | 0.00019429 | 0.00019429 |   0.0 |  0.00
Modify  | 0.36672    | 0.36672    | 0.36672    |   0.0 |  1.21
Other   |            | 0.0624     |            |       |  0.21

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5179.00 ave        5179 max        5179 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311324.0 ave      311324 max      311324 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311324
Ave neighs/atom = 155.66200
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 = 313.279036666325, Press = 0.725740358972677
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -7116.4167   -7116.4167   -7199.2059   -7199.2059    320.40281    320.40281    23503.045    23503.045    1170.1918    1170.1918 
   55000   -7118.0606   -7118.0606   -7199.9612   -7199.9612    316.96387    316.96387    23481.682    23481.682    2056.5488    2056.5488 
Loop time of 30.6408 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.820 ns/day, 8.511 hours/ns, 32.636 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    | 30.081     | 30.081     | 30.081     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12383    | 0.12383    | 0.12383    |   0.0 |  0.40
Output  | 0.0001538  | 0.0001538  | 0.0001538  |   0.0 |  0.00
Modify  | 0.37409    | 0.37409    | 0.37409    |   0.0 |  1.22
Other   |            | 0.06194    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5148.00 ave        5148 max        5148 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311646.0 ave      311646 max      311646 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311646
Ave neighs/atom = 155.82300
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 = 313.251514599292, Press = 0.970585450324845
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.575 | 4.575 | 4.575 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -7118.0606   -7118.0606   -7199.9612   -7199.9612    316.96387    316.96387    23481.682    23481.682    2056.5488    2056.5488 
   56000   -7121.4554   -7121.4554   -7200.9623   -7200.9623    307.70006    307.70006    23493.257    23493.257    1154.2849    1154.2849 
Loop time of 30.231 on 1 procs for 1000 steps with 2000 atoms

Performance: 2.858 ns/day, 8.397 hours/ns, 33.079 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    | 29.678     | 29.678     | 29.678     |   0.0 | 98.17
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.12248    | 0.12248    | 0.12248    |   0.0 |  0.41
Output  | 0.00042199 | 0.00042199 | 0.00042199 |   0.0 |  0.00
Modify  | 0.36816    | 0.36816    | 0.36816    |   0.0 |  1.22
Other   |            | 0.06172    |            |       |  0.20

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        5168.00 ave        5168 max        5168 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      311548.0 ave      311548 max      311548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311548
Ave neighs/atom = 155.77400
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_T313.15.out"  else  "print 'not_converged'  file output/vol_T313.15.out"
print '${V}'  file output/vol_T313.15.out
23512.0284267205

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0