# periodic boundary conditions along all three dimensions
boundary p p p

# Set neighbor skin
variable neigh_skin equal 2.0*${_u_distance}
variable neigh_skin equal 2.0*1
neighbor ${neigh_skin} bin
neighbor 2 bin

# create a supercell with cubic lattice (fcc, bcc, sc, or diamond)
# using 10*10*10 conventional (orthogonal) unit cells
variable latticeconst_converted equal 3.165197603404522*${_u_distance}
variable latticeconst_converted equal 3.165197603404522*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.16519760340452
Lattice spacing in x,y,z = 3.1651976 3.1651976 3.1651976
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 (31.651976 31.651976 31.651976)
  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 (31.651976 31.651976 31.651976)
  create_atoms CPU = 0.003 seconds

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

kim_interactions W

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

kim interactions W
#=== BEGIN kim interactions ==================================
pair_style kim EAM_Dynamo_MasonNguyenManhBecquart_2017_W__MO_268730733493_000
pair_coeff * * W
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 183.84

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.755 | 3.755 | 3.755 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -17713.921   -17713.921   -17800.004   -17800.004       333.15       333.15    31710.456    31710.456    2899.5926    2899.5926 
    1000   -17624.904   -17624.904   -17706.753   -17706.753     316.7639     316.7639    31856.267    31856.267   -1577.6094   -1577.6094 
Loop time of 10.375 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.328 ns/day, 2.882 hours/ns, 96.386 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    | 9.848      | 9.848      | 9.848      |   0.0 | 94.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099711   | 0.099711   | 0.099711   |   0.0 |  0.96
Output  | 0.00028352 | 0.00028352 | 0.00028352 |   0.0 |  0.00
Modify  | 0.36428    | 0.36428    | 0.36428    |   0.0 |  3.51
Other   |            | 0.0627     |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4119.00 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      128000.0 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -17624.904   -17624.904   -17706.753   -17706.753     316.7639     316.7639    31856.267    31856.267   -1577.6094   -1577.6094 
    2000   -17625.267   -17625.267   -17706.413   -17706.413     314.0416     314.0416    31829.093    31829.093    1314.2709    1314.2709 
Loop time of 11.0016 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.853 ns/day, 3.056 hours/ns, 90.896 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    | 10.457     | 10.457     | 10.457     |   0.0 | 95.05
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10172    | 0.10172    | 0.10172    |   0.0 |  0.92
Output  | 0.00022328 | 0.00022328 | 0.00022328 |   0.0 |  0.00
Modify  | 0.37942    | 0.37942    | 0.37942    |   0.0 |  3.45
Other   |            | 0.06277    |            |       |  0.57

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4008.00 ave        4008 max        4008 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125816.0 ave      125816 max      125816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125816
Ave neighs/atom = 62.908000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000   -17625.267   -17625.267   -17706.413   -17706.413     314.0416     314.0416    31829.093    31829.093    1314.2709    1314.2709 
    3000   -17626.915   -17626.915   -17714.652   -17714.652    339.55258    339.55258    31819.237    31819.237    781.95912    781.95912 
Loop time of 10.5543 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.186 ns/day, 2.932 hours/ns, 94.748 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    | 10.037     | 10.037     | 10.037     |   0.0 | 95.10
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096559   | 0.096559   | 0.096559   |   0.0 |  0.91
Output  | 0.00023544 | 0.00023544 | 0.00023544 |   0.0 |  0.00
Modify  | 0.35884    | 0.35884    | 0.35884    |   0.0 |  3.40
Other   |            | 0.06158    |            |       |  0.58

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3989.00 ave        3989 max        3989 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125860.0 ave      125860 max      125860 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125860
Ave neighs/atom = 62.930000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -17626.915   -17626.915   -17714.652   -17714.652    339.55258    339.55258    31819.237    31819.237    781.95912    781.95912 
    4000    -17623.96    -17623.96   -17711.716   -17711.716    339.62706    339.62706    31845.203    31845.203   -967.78684   -967.78684 
Loop time of 10.2443 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.434 ns/day, 2.846 hours/ns, 97.615 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    | 9.748      | 9.748      | 9.748      |   0.0 | 95.16
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093767   | 0.093767   | 0.093767   |   0.0 |  0.92
Output  | 0.00018561 | 0.00018561 | 0.00018561 |   0.0 |  0.00
Modify  | 0.34118    | 0.34118    | 0.34118    |   0.0 |  3.33
Other   |            | 0.06115    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4004.00 ave        4004 max        4004 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126126.0 ave      126126 max      126126 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126126
Ave neighs/atom = 63.063000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000    -17623.96    -17623.96   -17711.716   -17711.716    339.62706    339.62706    31845.203    31845.203   -967.78684   -967.78684 
    5000   -17626.358   -17626.358   -17715.059   -17715.059    343.27954    343.27954    31842.114    31842.114   -1082.5757   -1082.5757 
Loop time of 10.1113 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.545 ns/day, 2.809 hours/ns, 98.899 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    | 9.6196     | 9.6196     | 9.6196     |   0.0 | 95.14
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092839   | 0.092839   | 0.092839   |   0.0 |  0.92
Output  | 0.00019542 | 0.00019542 | 0.00019542 |   0.0 |  0.00
Modify  | 0.33857    | 0.33857    | 0.33857    |   0.0 |  3.35
Other   |            | 0.0601     |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3976.00 ave        3976 max        3976 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125870.0 ave      125870 max      125870 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125870
Ave neighs/atom = 62.935000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.196942796697, Press = 174.178139499948
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -17626.358   -17626.358   -17715.059   -17715.059    343.27954    343.27954    31842.114    31842.114   -1082.5757   -1082.5757 
    6000   -17625.193   -17625.193   -17710.178   -17710.178    328.90422    328.90422     31861.46     31861.46   -2259.3957   -2259.3957 
Loop time of 10.2562 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.424 ns/day, 2.849 hours/ns, 97.502 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    | 9.7436     | 9.7436     | 9.7436     |   0.0 | 95.00
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093818   | 0.093818   | 0.093818   |   0.0 |  0.91
Output  | 0.0001514  | 0.0001514  | 0.0001514  |   0.0 |  0.00
Modify  | 0.3579     | 0.3579     | 0.3579     |   0.0 |  3.49
Other   |            | 0.06074    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4007.00 ave        4007 max        4007 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125958.0 ave      125958 max      125958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125958
Ave neighs/atom = 62.979000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.344289637322, Press = 9.12999850231991
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -17625.193   -17625.193   -17710.178   -17710.178    328.90422    328.90422     31861.46     31861.46   -2259.3957   -2259.3957 
    7000   -17621.034   -17621.034   -17707.478   -17707.478    334.54819    334.54819    31825.061    31825.061    1726.9221    1726.9221 
Loop time of 10.6492 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.113 ns/day, 2.958 hours/ns, 93.904 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    | 10.115     | 10.115     | 10.115     |   0.0 | 94.98
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096407   | 0.096407   | 0.096407   |   0.0 |  0.91
Output  | 0.00019733 | 0.00019733 | 0.00019733 |   0.0 |  0.00
Modify  | 0.37662    | 0.37662    | 0.37662    |   0.0 |  3.54
Other   |            | 0.06109    |            |       |  0.57

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3988.00 ave        3988 max        3988 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125752.0 ave      125752 max      125752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125752
Ave neighs/atom = 62.876000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.86414344275, Press = 11.9504469715005
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -17621.034   -17621.034   -17707.478   -17707.478    334.54819    334.54819    31825.061    31825.061    1726.9221    1726.9221 
    8000   -17625.475   -17625.475   -17713.317   -17713.317    339.95626    339.95626    31827.931    31827.931    800.44122    800.44122 
Loop time of 10.3098 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.380 ns/day, 2.864 hours/ns, 96.996 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    | 9.7982     | 9.7982     | 9.7982     |   0.0 | 95.04
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093806   | 0.093806   | 0.093806   |   0.0 |  0.91
Output  | 0.00015402 | 0.00015402 | 0.00015402 |   0.0 |  0.00
Modify  | 0.35772    | 0.35772    | 0.35772    |   0.0 |  3.47
Other   |            | 0.05989    |            |       |  0.58

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4008.00 ave        4008 max        4008 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125852.0 ave      125852 max      125852 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125852
Ave neighs/atom = 62.926000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.088358195144, Press = -5.99741570599089
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -17625.475   -17625.475   -17713.317   -17713.317    339.95626    339.95626    31827.931    31827.931    800.44122    800.44122 
    9000   -17620.816   -17620.816   -17706.927   -17706.927    333.25937    333.25937    31848.791    31848.791   -729.54338   -729.54338 
Loop time of 10.8241 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.982 ns/day, 3.007 hours/ns, 92.386 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    | 10.28      | 10.28      | 10.28      |   0.0 | 94.97
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097514   | 0.097514   | 0.097514   |   0.0 |  0.90
Output  | 0.00015645 | 0.00015645 | 0.00015645 |   0.0 |  0.00
Modify  | 0.38541    | 0.38541    | 0.38541    |   0.0 |  3.56
Other   |            | 0.06095    |            |       |  0.56

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3987.00 ave        3987 max        3987 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126112.0 ave      126112 max      126112 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126112
Ave neighs/atom = 63.056000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.374572093041, Press = -4.28522801432182
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -17620.816   -17620.816   -17706.927   -17706.927    333.25937    333.25937    31848.791    31848.791   -729.54338   -729.54338 
   10000   -17625.525   -17625.525   -17710.791   -17710.791    329.98889    329.98889     31898.44     31898.44   -5189.1155   -5189.1155 
Loop time of 10.2529 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.427 ns/day, 2.848 hours/ns, 97.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    | 9.7361     | 9.7361     | 9.7361     |   0.0 | 94.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0931     | 0.0931     | 0.0931     |   0.0 |  0.91
Output  | 0.00016057 | 0.00016057 | 0.00016057 |   0.0 |  0.00
Modify  | 0.36273    | 0.36273    | 0.36273    |   0.0 |  3.54
Other   |            | 0.06077    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3969.00 ave        3969 max        3969 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125886.0 ave      125886 max      125886 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125886
Ave neighs/atom = 62.943000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.599946918638, Press = -7.08051892949041
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -17625.525   -17625.525   -17710.791   -17710.791    329.98889    329.98889     31898.44     31898.44   -5189.1155   -5189.1155 
   11000   -17620.011   -17620.011   -17708.516   -17708.516    342.52325    342.52325    31857.977    31857.977   -1280.9065   -1280.9065 
Loop time of 10.1015 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.553 ns/day, 2.806 hours/ns, 98.995 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    | 9.5926     | 9.5926     | 9.5926     |   0.0 | 94.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092576   | 0.092576   | 0.092576   |   0.0 |  0.92
Output  | 0.0001547  | 0.0001547  | 0.0001547  |   0.0 |  0.00
Modify  | 0.35439    | 0.35439    | 0.35439    |   0.0 |  3.51
Other   |            | 0.06171    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3987.00 ave        3987 max        3987 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125846.0 ave      125846 max      125846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125846
Ave neighs/atom = 62.923000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.485225661747, Press = 5.33641916427395
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -17620.011   -17620.011   -17708.516   -17708.516    342.52325    342.52325    31857.977    31857.977   -1280.9065   -1280.9065 
   12000   -17624.448   -17624.448   -17708.244   -17708.244    324.29885    324.29885    31821.077    31821.077    1281.3574    1281.3574 
Loop time of 10.0328 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.612 ns/day, 2.787 hours/ns, 99.673 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    | 9.5283     | 9.5283     | 9.5283     |   0.0 | 94.97
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09295    | 0.09295    | 0.09295    |   0.0 |  0.93
Output  | 0.0001559  | 0.0001559  | 0.0001559  |   0.0 |  0.00
Modify  | 0.35091    | 0.35091    | 0.35091    |   0.0 |  3.50
Other   |            | 0.0605     |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3991.00 ave        3991 max        3991 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125842.0 ave      125842 max      125842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125842
Ave neighs/atom = 62.921000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.870959118157, Press = 3.5893661056724
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -17624.448   -17624.448   -17708.244   -17708.244    324.29885    324.29885    31821.077    31821.077    1281.3574    1281.3574 
   13000   -17627.989   -17627.989   -17714.388   -17714.388    334.37133    334.37133    31834.089    31834.089   -242.29982   -242.29982 
Loop time of 10.0803 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.571 ns/day, 2.800 hours/ns, 99.203 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5727     | 9.5727     | 9.5727     |   0.0 | 94.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093109   | 0.093109   | 0.093109   |   0.0 |  0.92
Output  | 0.00015441 | 0.00015441 | 0.00015441 |   0.0 |  0.00
Modify  | 0.35452    | 0.35452    | 0.35452    |   0.0 |  3.52
Other   |            | 0.05976    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3981.00 ave        3981 max        3981 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125930.0 ave      125930 max      125930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125930
Ave neighs/atom = 62.965000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.605673663119, Press = 5.48704203011174
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -17627.989   -17627.989   -17714.388   -17714.388    334.37133    334.37133    31834.089    31834.089   -242.29982   -242.29982 
   14000   -17622.368   -17622.368   -17708.648   -17708.648    333.91484    333.91484    31854.196    31854.196   -1187.3563   -1187.3563 
Loop time of 10.1297 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.529 ns/day, 2.814 hours/ns, 98.720 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    | 9.6209     | 9.6209     | 9.6209     |   0.0 | 94.98
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093129   | 0.093129   | 0.093129   |   0.0 |  0.92
Output  | 0.00020746 | 0.00020746 | 0.00020746 |   0.0 |  0.00
Modify  | 0.35433    | 0.35433    | 0.35433    |   0.0 |  3.50
Other   |            | 0.06117    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3997.00 ave        3997 max        3997 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126018.0 ave      126018 max      126018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126018
Ave neighs/atom = 63.009000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.655398973192, Press = 2.87237966107399
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -17622.368   -17622.368   -17708.648   -17708.648    333.91484    333.91484    31854.196    31854.196   -1187.3563   -1187.3563 
   15000   -17627.474   -17627.474   -17711.759   -17711.759    326.19172    326.19172    31799.311    31799.311    2689.4841    2689.4841 
Loop time of 10.2562 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.424 ns/day, 2.849 hours/ns, 97.502 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    | 9.7432     | 9.7432     | 9.7432     |   0.0 | 95.00
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09236    | 0.09236    | 0.09236    |   0.0 |  0.90
Output  | 0.00015548 | 0.00015548 | 0.00015548 |   0.0 |  0.00
Modify  | 0.3603     | 0.3603     | 0.3603     |   0.0 |  3.51
Other   |            | 0.06019    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3935.00 ave        3935 max        3935 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125820.0 ave      125820 max      125820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125820
Ave neighs/atom = 62.910000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.699827353494, Press = -6.67168321231334
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -17627.474   -17627.474   -17711.759   -17711.759    326.19172    326.19172    31799.311    31799.311    2689.4841    2689.4841 
   16000   -17623.932   -17623.932   -17709.454   -17709.454    330.97942    330.97942    31850.898    31850.898   -1046.3937   -1046.3937 
Loop time of 10.0572 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.591 ns/day, 2.794 hours/ns, 99.431 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    | 9.5505     | 9.5505     | 9.5505     |   0.0 | 94.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093097   | 0.093097   | 0.093097   |   0.0 |  0.93
Output  | 0.00015482 | 0.00015482 | 0.00015482 |   0.0 |  0.00
Modify  | 0.35297    | 0.35297    | 0.35297    |   0.0 |  3.51
Other   |            | 0.06048    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4008.00 ave        4008 max        4008 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126016.0 ave      126016 max      126016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126016
Ave neighs/atom = 63.008000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.822513723766, Press = 3.26766357299502
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -17623.932   -17623.932   -17709.454   -17709.454    330.97942    330.97942    31850.898    31850.898   -1046.3937   -1046.3937 
   17000   -17625.112   -17625.112   -17709.864   -17709.864    327.99921    327.99921     31827.68     31827.68    963.11623    963.11623 
Loop time of 10.383 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.321 ns/day, 2.884 hours/ns, 96.312 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    | 9.856      | 9.856      | 9.856      |   0.0 | 94.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095273   | 0.095273   | 0.095273   |   0.0 |  0.92
Output  | 0.00015444 | 0.00015444 | 0.00015444 |   0.0 |  0.00
Modify  | 0.37037    | 0.37037    | 0.37037    |   0.0 |  3.57
Other   |            | 0.06112    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3957.00 ave        3957 max        3957 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125848.0 ave      125848 max      125848 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125848
Ave neighs/atom = 62.924000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.805411287606, Press = 1.89350689473172
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -17625.112   -17625.112   -17709.864   -17709.864    327.99921    327.99921     31827.68     31827.68    963.11623    963.11623 
   18000   -17626.135   -17626.135   -17712.568   -17712.568    334.50623    334.50623    31850.117    31850.117   -1473.7136   -1473.7136 
Loop time of 10.2595 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.421 ns/day, 2.850 hours/ns, 97.471 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    | 9.7437     | 9.7437     | 9.7437     |   0.0 | 94.97
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094542   | 0.094542   | 0.094542   |   0.0 |  0.92
Output  | 0.00015683 | 0.00015683 | 0.00015683 |   0.0 |  0.00
Modify  | 0.36044    | 0.36044    | 0.36044    |   0.0 |  3.51
Other   |            | 0.06061    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3992.00 ave        3992 max        3992 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125922.0 ave      125922 max      125922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125922
Ave neighs/atom = 62.961000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.731263926815, Press = -2.33499395420031
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -17626.135   -17626.135   -17712.568   -17712.568    334.50623    334.50623    31850.117    31850.117   -1473.7136   -1473.7136 
   19000   -17621.297   -17621.297   -17708.527   -17708.527    337.58899    337.58899    31852.203    31852.203   -1206.1812   -1206.1812 
Loop time of 10.0622 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.587 ns/day, 2.795 hours/ns, 99.382 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    | 9.5536     | 9.5536     | 9.5536     |   0.0 | 94.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093156   | 0.093156   | 0.093156   |   0.0 |  0.93
Output  | 0.00015423 | 0.00015423 | 0.00015423 |   0.0 |  0.00
Modify  | 0.35442    | 0.35442    | 0.35442    |   0.0 |  3.52
Other   |            | 0.06084    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3998.00 ave        3998 max        3998 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125972.0 ave      125972 max      125972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125972
Ave neighs/atom = 62.986000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.670049870258, Press = 0.91035800496257
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -17621.297   -17621.297   -17708.527   -17708.527    337.58899    337.58899    31852.203    31852.203   -1206.1812   -1206.1812 
   20000   -17625.995   -17625.995   -17713.266   -17713.266     337.7468     337.7468    31823.131    31823.131    704.17134    704.17134 
Loop time of 10.1585 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.505 ns/day, 2.822 hours/ns, 98.440 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    | 9.6489     | 9.6489     | 9.6489     |   0.0 | 94.98
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093139   | 0.093139   | 0.093139   |   0.0 |  0.92
Output  | 0.00015528 | 0.00015528 | 0.00015528 |   0.0 |  0.00
Modify  | 0.35529    | 0.35529    | 0.35529    |   0.0 |  3.50
Other   |            | 0.061      |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4000.00 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125890.0 ave      125890 max      125890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125890
Ave neighs/atom = 62.945000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.741520609322, Press = -1.51434970978653
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -17625.995   -17625.995   -17713.266   -17713.266     337.7468     337.7468    31823.131    31823.131    704.17134    704.17134 
   21000   -17624.172   -17624.172   -17709.517   -17709.517      330.295      330.295     31890.69     31890.69    -5180.823    -5180.823 
Loop time of 10.5473 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.192 ns/day, 2.930 hours/ns, 94.811 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    | 10.012     | 10.012     | 10.012     |   0.0 | 94.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096353   | 0.096353   | 0.096353   |   0.0 |  0.91
Output  | 0.00015351 | 0.00015351 | 0.00015351 |   0.0 |  0.00
Modify  | 0.37685    | 0.37685    | 0.37685    |   0.0 |  3.57
Other   |            | 0.06203    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4002.00 ave        4002 max        4002 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125984.0 ave      125984 max      125984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125984
Ave neighs/atom = 62.992000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.572917915238, Press = -2.346737271751
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -17624.172   -17624.172   -17709.517   -17709.517      330.295      330.295     31890.69     31890.69    -5180.823    -5180.823 
   22000   -17628.505   -17628.505   -17715.864   -17715.864    338.09091    338.09091    31833.832    31833.832    -740.9957    -740.9957 
Loop time of 10.2593 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.422 ns/day, 2.850 hours/ns, 97.472 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    | 9.7409     | 9.7409     | 9.7409     |   0.0 | 94.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094329   | 0.094329   | 0.094329   |   0.0 |  0.92
Output  | 0.00015431 | 0.00015431 | 0.00015431 |   0.0 |  0.00
Modify  | 0.3639     | 0.3639     | 0.3639     |   0.0 |  3.55
Other   |            | 0.06001    |            |       |  0.58

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3972.00 ave        3972 max        3972 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125744.0 ave      125744 max      125744 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125744
Ave neighs/atom = 62.872000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.470682021575, Press = 1.70785431093365
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -17628.505   -17628.505   -17715.864   -17715.864    338.09091    338.09091    31833.832    31833.832    -740.9957    -740.9957 
   23000   -17626.707   -17626.707   -17712.546   -17712.546    332.20876    332.20876     31848.02     31848.02    -1416.533    -1416.533 
Loop time of 10.7908 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.007 ns/day, 2.997 hours/ns, 92.672 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    | 10.246     | 10.246     | 10.246     |   0.0 | 94.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097711   | 0.097711   | 0.097711   |   0.0 |  0.91
Output  | 0.00015562 | 0.00015562 | 0.00015562 |   0.0 |  0.00
Modify  | 0.38519    | 0.38519    | 0.38519    |   0.0 |  3.57
Other   |            | 0.06211    |            |       |  0.58

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4001.00 ave        4001 max        4001 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126006.0 ave      126006 max      126006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126006
Ave neighs/atom = 63.003000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.437883531008, Press = 1.96110446694054
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -17626.707   -17626.707   -17712.546   -17712.546    332.20876    332.20876     31848.02     31848.02    -1416.533    -1416.533 
   24000   -17624.239   -17624.239   -17711.077   -17711.077    336.06991    336.06991    31792.908    31792.908    3713.3299    3713.3299 
Loop time of 10.129 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.530 ns/day, 2.814 hours/ns, 98.726 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    | 9.6189     | 9.6189     | 9.6189     |   0.0 | 94.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093214   | 0.093214   | 0.093214   |   0.0 |  0.92
Output  | 0.00015722 | 0.00015722 | 0.00015722 |   0.0 |  0.00
Modify  | 0.35645    | 0.35645    | 0.35645    |   0.0 |  3.52
Other   |            | 0.06035    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3988.00 ave        3988 max        3988 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125962.0 ave      125962 max      125962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125962
Ave neighs/atom = 62.981000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.469185886144, Press = 0.942580310345214
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -17624.239   -17624.239   -17711.077   -17711.077    336.06991    336.06991    31792.908    31792.908    3713.3299    3713.3299 
   25000   -17624.726   -17624.726   -17709.276   -17709.276     327.2154     327.2154    31874.241    31874.241   -3550.3852   -3550.3852 
Loop time of 10.1715 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.494 ns/day, 2.825 hours/ns, 98.314 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.6564     | 9.6564     | 9.6564     |   0.0 | 94.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094404   | 0.094404   | 0.094404   |   0.0 |  0.93
Output  | 0.00020172 | 0.00020172 | 0.00020172 |   0.0 |  0.00
Modify  | 0.35919    | 0.35919    | 0.35919    |   0.0 |  3.53
Other   |            | 0.06138    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4027.00 ave        4027 max        4027 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126060.0 ave      126060 max      126060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126060
Ave neighs/atom = 63.030000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.508536784148, Press = 0.19451602981875
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -17624.726   -17624.726   -17709.276   -17709.276     327.2154     327.2154    31874.241    31874.241   -3550.3852   -3550.3852 
   26000    -17625.64    -17625.64   -17711.149   -17711.149    330.92979    330.92979    31832.107    31832.107   -170.40617   -170.40617 
Loop time of 10.7668 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.025 ns/day, 2.991 hours/ns, 92.878 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 10.22      | 10.22      | 10.22      |   0.0 | 94.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0981     | 0.0981     | 0.0981     |   0.0 |  0.91
Output  | 0.00015371 | 0.00015371 | 0.00015371 |   0.0 |  0.00
Modify  | 0.38594    | 0.38594    | 0.38594    |   0.0 |  3.58
Other   |            | 0.06265    |            |       |  0.58

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3962.00 ave        3962 max        3962 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125800.0 ave      125800 max      125800 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125800
Ave neighs/atom = 62.900000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.468908035397, Press = 0.87045707132221
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000    -17625.64    -17625.64   -17711.149   -17711.149    330.92979    330.92979    31832.107    31832.107   -170.40617   -170.40617 
   27000   -17626.319   -17626.319   -17711.763   -17711.763     330.6762     330.6762    31813.538    31813.538    1906.3812    1906.3812 
Loop time of 10.3682 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.333 ns/day, 2.880 hours/ns, 96.449 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    | 9.8416     | 9.8416     | 9.8416     |   0.0 | 94.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095191   | 0.095191   | 0.095191   |   0.0 |  0.92
Output  | 0.00015605 | 0.00015605 | 0.00015605 |   0.0 |  0.00
Modify  | 0.37013    | 0.37013    | 0.37013    |   0.0 |  3.57
Other   |            | 0.06112    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3986.00 ave        3986 max        3986 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125930.0 ave      125930 max      125930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125930
Ave neighs/atom = 62.965000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.455606814226, Press = 0.324424032124445
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -17626.319   -17626.319   -17711.763   -17711.763     330.6762     330.6762    31813.538    31813.538    1906.3812    1906.3812 
   28000   -17622.535   -17622.535   -17710.226   -17710.226    339.37388    339.37388    31871.658    31871.658    -2635.405    -2635.405 
Loop time of 10.7355 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.048 ns/day, 2.982 hours/ns, 93.149 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    | 10.193     | 10.193     | 10.193     |   0.0 | 94.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098131   | 0.098131   | 0.098131   |   0.0 |  0.91
Output  | 0.00015543 | 0.00015543 | 0.00015543 |   0.0 |  0.00
Modify  | 0.38253    | 0.38253    | 0.38253    |   0.0 |  3.56
Other   |            | 0.06153    |            |       |  0.57

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4020.00 ave        4020 max        4020 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125992.0 ave      125992 max      125992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125992
Ave neighs/atom = 62.996000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.50216088669, Press = 0.445872027873654
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -17622.535   -17622.535   -17710.226   -17710.226    339.37388    339.37388    31871.658    31871.658    -2635.405    -2635.405 
   29000   -17627.222   -17627.222    -17713.74    -17713.74    334.83468    334.83468    31824.308    31824.308    827.06428    827.06428 
Loop time of 10.0708 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.579 ns/day, 2.797 hours/ns, 99.297 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    | 9.5626     | 9.5626     | 9.5626     |   0.0 | 94.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092283   | 0.092283   | 0.092283   |   0.0 |  0.92
Output  | 0.00015353 | 0.00015353 | 0.00015353 |   0.0 |  0.00
Modify  | 0.35597    | 0.35597    | 0.35597    |   0.0 |  3.53
Other   |            | 0.05978    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3977.00 ave        3977 max        3977 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125904.0 ave      125904 max      125904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125904
Ave neighs/atom = 62.952000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.38058523726, Press = 2.57539546321446
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000   -17627.222   -17627.222    -17713.74    -17713.74    334.83468    334.83468    31824.308    31824.308    827.06428    827.06428 
   30000   -17624.444   -17624.444   -17710.695   -17710.695    333.79879    333.79879     31820.96     31820.96    1579.7366    1579.7366 
Loop time of 10.1119 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.544 ns/day, 2.809 hours/ns, 98.894 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    | 9.6016     | 9.6016     | 9.6016     |   0.0 | 94.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094369   | 0.094369   | 0.094369   |   0.0 |  0.93
Output  | 0.0001963  | 0.0001963  | 0.0001963  |   0.0 |  0.00
Modify  | 0.35518    | 0.35518    | 0.35518    |   0.0 |  3.51
Other   |            | 0.0605     |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3977.00 ave        3977 max        3977 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126076.0 ave      126076 max      126076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126076
Ave neighs/atom = 63.038000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.329510289139, Press = -0.849298386773934
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -17624.444   -17624.444   -17710.695   -17710.695    333.79879    333.79879     31820.96     31820.96    1579.7366    1579.7366 
   31000   -17627.234   -17627.234   -17710.521   -17710.521    322.33181    322.33181    31863.461    31863.461   -2091.7278   -2091.7278 
Loop time of 10.349 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.349 ns/day, 2.875 hours/ns, 96.628 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    | 9.8219     | 9.8219     | 9.8219     |   0.0 | 94.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095935   | 0.095935   | 0.095935   |   0.0 |  0.93
Output  | 0.00015426 | 0.00015426 | 0.00015426 |   0.0 |  0.00
Modify  | 0.3699     | 0.3699     | 0.3699     |   0.0 |  3.57
Other   |            | 0.06112    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3980.00 ave        3980 max        3980 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126006.0 ave      126006 max      126006 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126006
Ave neighs/atom = 63.003000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.320317592127, Press = 0.680317662000084
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -17627.234   -17627.234   -17710.521   -17710.521    322.33181    322.33181    31863.461    31863.461   -2091.7278   -2091.7278 
   32000   -17619.422   -17619.422   -17709.477   -17709.477    348.52238    348.52238    31815.971    31815.971    2795.3349    2795.3349 
Loop time of 10.6905 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.082 ns/day, 2.970 hours/ns, 93.541 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    | 10.143     | 10.143     | 10.143     |   0.0 | 94.88
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099371   | 0.099371   | 0.099371   |   0.0 |  0.93
Output  | 0.0001553  | 0.0001553  | 0.0001553  |   0.0 |  0.00
Modify  | 0.38472    | 0.38472    | 0.38472    |   0.0 |  3.60
Other   |            | 0.06333    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3988.00 ave        3988 max        3988 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125936.0 ave      125936 max      125936 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125936
Ave neighs/atom = 62.968000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.311733840282, Press = 0.493139071390455
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -17619.422   -17619.422   -17709.477   -17709.477    348.52238    348.52238    31815.971    31815.971    2795.3349    2795.3349 
   33000   -17626.027   -17626.027   -17712.015   -17712.015    332.78525    332.78525    31859.373    31859.373   -2111.2192   -2111.2192 
Loop time of 10.381 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.323 ns/day, 2.884 hours/ns, 96.330 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    | 9.8553     | 9.8553     | 9.8553     |   0.0 | 94.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095982   | 0.095982   | 0.095982   |   0.0 |  0.92
Output  | 0.00019674 | 0.00019674 | 0.00019674 |   0.0 |  0.00
Modify  | 0.3682     | 0.3682     | 0.3682     |   0.0 |  3.55
Other   |            | 0.0613     |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3998.00 ave        3998 max        3998 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126028.0 ave      126028 max      126028 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126028
Ave neighs/atom = 63.014000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.360449056324, Press = -0.221845164664388
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -17626.027   -17626.027   -17712.015   -17712.015    332.78525    332.78525    31859.373    31859.373   -2111.2192   -2111.2192 
   34000   -17623.084   -17623.084   -17708.984   -17708.984    332.43913    332.43913     31838.11     31838.11    453.01556    453.01556 
Loop time of 11.2209 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.700 ns/day, 3.117 hours/ns, 89.120 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    | 10.629     | 10.629     | 10.629     |   0.0 | 94.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10518    | 0.10518    | 0.10518    |   0.0 |  0.94
Output  | 0.00015371 | 0.00015371 | 0.00015371 |   0.0 |  0.00
Modify  | 0.42186    | 0.42186    | 0.42186    |   0.0 |  3.76
Other   |            | 0.06416    |            |       |  0.57

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4022.00 ave        4022 max        4022 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125908.0 ave      125908 max      125908 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125908
Ave neighs/atom = 62.954000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.381108592646, Press = 1.25427441101119
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -17623.084   -17623.084   -17708.984   -17708.984    332.43913    332.43913     31838.11     31838.11    453.01556    453.01556 
   35000   -17624.923   -17624.923   -17712.294   -17712.294    338.13816    338.13816    31787.996    31787.996    3930.6539    3930.6539 
Loop time of 10.8104 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.992 ns/day, 3.003 hours/ns, 92.503 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    | 10.264     | 10.264     | 10.264     |   0.0 | 94.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099485   | 0.099485   | 0.099485   |   0.0 |  0.92
Output  | 0.00015132 | 0.00015132 | 0.00015132 |   0.0 |  0.00
Modify  | 0.38472    | 0.38472    | 0.38472    |   0.0 |  3.56
Other   |            | 0.06173    |            |       |  0.57

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3994.00 ave        3994 max        3994 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125896.0 ave      125896 max      125896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125896
Ave neighs/atom = 62.948000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.267165801337, Press = -2.77205152219881
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -17624.923   -17624.923   -17712.294   -17712.294    338.13816    338.13816    31787.996    31787.996    3930.6539    3930.6539 
   36000   -17630.189   -17630.189   -17711.887   -17711.887    316.18195    316.18195    31855.496    31855.496   -2279.8802   -2279.8802 
Loop time of 10.1053 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.550 ns/day, 2.807 hours/ns, 98.958 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    | 9.5954     | 9.5954     | 9.5954     |   0.0 | 94.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093673   | 0.093673   | 0.093673   |   0.0 |  0.93
Output  | 0.00019521 | 0.00019521 | 0.00019521 |   0.0 |  0.00
Modify  | 0.35581    | 0.35581    | 0.35581    |   0.0 |  3.52
Other   |            | 0.06022    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3994.00 ave        3994 max        3994 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126072.0 ave      126072 max      126072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126072
Ave neighs/atom = 63.036000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.181828038505, Press = 1.52675533877438
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -17630.189   -17630.189   -17711.887   -17711.887    316.18195    316.18195    31855.496    31855.496   -2279.8802   -2279.8802 
   37000   -17623.485   -17623.485   -17710.176   -17710.176    335.50024    335.50024    31850.134    31850.134   -970.42885   -970.42885 
Loop time of 10.4369 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.278 ns/day, 2.899 hours/ns, 95.814 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    | 9.9101     | 9.9101     | 9.9101     |   0.0 | 94.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096039   | 0.096039   | 0.096039   |   0.0 |  0.92
Output  | 0.00019749 | 0.00019749 | 0.00019749 |   0.0 |  0.00
Modify  | 0.36934    | 0.36934    | 0.36934    |   0.0 |  3.54
Other   |            | 0.06126    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3994.00 ave        3994 max        3994 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125862.0 ave      125862 max      125862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125862
Ave neighs/atom = 62.931000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.076785265629, Press = 1.81799200308802
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -17623.485   -17623.485   -17710.176   -17710.176    335.50024    335.50024    31850.134    31850.134   -970.42885   -970.42885 
   38000   -17624.423   -17624.423    -17711.64    -17711.64    337.53844    337.53844    31831.876    31831.876    483.33152    483.33152 
Loop time of 10.8931 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.932 ns/day, 3.026 hours/ns, 91.802 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    | 10.336     | 10.336     | 10.336     |   0.0 | 94.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10104    | 0.10104    | 0.10104    |   0.0 |  0.93
Output  | 0.00016121 | 0.00016121 | 0.00016121 |   0.0 |  0.00
Modify  | 0.39263    | 0.39263    | 0.39263    |   0.0 |  3.60
Other   |            | 0.06302    |            |       |  0.58

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3991.00 ave        3991 max        3991 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125926.0 ave      125926 max      125926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125926
Ave neighs/atom = 62.963000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.013853196894, Press = -1.05925300320181
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -17624.423   -17624.423    -17711.64    -17711.64    337.53844    337.53844    31831.876    31831.876    483.33152    483.33152 
   39000   -17626.749   -17626.749   -17711.819   -17711.819    329.22958    329.22958     31854.53     31854.53   -2014.9125   -2014.9125 
Loop time of 10.059 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.589 ns/day, 2.794 hours/ns, 99.413 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    | 9.5527     | 9.5527     | 9.5527     |   0.0 | 94.97
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092489   | 0.092489   | 0.092489   |   0.0 |  0.92
Output  | 0.00015511 | 0.00015511 | 0.00015511 |   0.0 |  0.00
Modify  | 0.35363    | 0.35363    | 0.35363    |   0.0 |  3.52
Other   |            | 0.06003    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4008.00 ave        4008 max        4008 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126016.0 ave      126016 max      126016 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126016
Ave neighs/atom = 63.008000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.054614772605, Press = 2.4256337927502
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -17626.749   -17626.749   -17711.819   -17711.819    329.22958    329.22958     31854.53     31854.53   -2014.9125   -2014.9125 
   40000   -17626.827   -17626.827   -17712.049   -17712.049     329.8164     329.8164    31804.638    31804.638    2513.1595    2513.1595 
Loop time of 10.0847 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.567 ns/day, 2.801 hours/ns, 99.160 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    | 9.5739     | 9.5739     | 9.5739     |   0.0 | 94.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093728   | 0.093728   | 0.093728   |   0.0 |  0.93
Output  | 0.0001525  | 0.0001525  | 0.0001525  |   0.0 |  0.00
Modify  | 0.35564    | 0.35564    | 0.35564    |   0.0 |  3.53
Other   |            | 0.06121    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3982.00 ave        3982 max        3982 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125840.0 ave      125840 max      125840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125840
Ave neighs/atom = 62.920000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.05003745955, Press = 0.599181643204594
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -17626.827   -17626.827   -17712.049   -17712.049     329.8164     329.8164    31804.638    31804.638    2513.1595    2513.1595 
   41000   -17624.786   -17624.786   -17712.686   -17712.686    340.18362    340.18362     31813.12     31813.12    1960.3162    1960.3162 
Loop time of 10.0647 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.584 ns/day, 2.796 hours/ns, 99.357 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    | 9.5575     | 9.5575     | 9.5575     |   0.0 | 94.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093158   | 0.093158   | 0.093158   |   0.0 |  0.93
Output  | 0.00015608 | 0.00015608 | 0.00015608 |   0.0 |  0.00
Modify  | 0.3535     | 0.3535     | 0.3535     |   0.0 |  3.51
Other   |            | 0.06039    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4010.00 ave        4010 max        4010 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126084.0 ave      126084 max      126084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126084
Ave neighs/atom = 63.042000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.019015098611, Press = -0.82551421556698
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -17624.786   -17624.786   -17712.686   -17712.686    340.18362    340.18362     31813.12     31813.12    1960.3162    1960.3162 
   42000   -17622.574   -17622.574   -17710.344   -17710.344    339.68132    339.68132    31842.748    31842.748     64.81754     64.81754 
Loop time of 10.4729 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.250 ns/day, 2.909 hours/ns, 95.484 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    | 9.9414     | 9.9414     | 9.9414     |   0.0 | 94.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097201   | 0.097201   | 0.097201   |   0.0 |  0.93
Output  | 0.00016479 | 0.00016479 | 0.00016479 |   0.0 |  0.00
Modify  | 0.37326    | 0.37326    | 0.37326    |   0.0 |  3.56
Other   |            | 0.06092    |            |       |  0.58

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4013.00 ave        4013 max        4013 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126072.0 ave      126072 max      126072 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126072
Ave neighs/atom = 63.036000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.008010054105, Press = 0.427679646834044
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -17622.574   -17622.574   -17710.344   -17710.344    339.68132    339.68132    31842.748    31842.748     64.81754     64.81754 
   43000   -17622.593   -17622.593   -17710.114   -17710.114     338.7136     338.7136    31847.776    31847.776   -786.36299   -786.36299 
Loop time of 10.2499 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.429 ns/day, 2.847 hours/ns, 97.562 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.73       | 9.73       | 9.73       |   0.0 | 94.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095209   | 0.095209   | 0.095209   |   0.0 |  0.93
Output  | 0.0001906  | 0.0001906  | 0.0001906  |   0.0 |  0.00
Modify  | 0.36294    | 0.36294    | 0.36294    |   0.0 |  3.54
Other   |            | 0.06162    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4029.00 ave        4029 max        4029 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125980.0 ave      125980 max      125980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125980
Ave neighs/atom = 62.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.969498160255, Press = -0.148755810750088
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -17622.593   -17622.593   -17710.114   -17710.114     338.7136     338.7136    31847.776    31847.776   -786.36299   -786.36299 
   44000   -17628.269   -17628.269   -17712.198   -17712.198     324.8137     324.8137    31831.786    31831.786    283.50754    283.50754 
Loop time of 10.9663 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.879 ns/day, 3.046 hours/ns, 91.188 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    | 10.404     | 10.404     | 10.404     |   0.0 | 94.87
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10074    | 0.10074    | 0.10074    |   0.0 |  0.92
Output  | 0.00028555 | 0.00028555 | 0.00028555 |   0.0 |  0.00
Modify  | 0.39801    | 0.39801    | 0.39801    |   0.0 |  3.63
Other   |            | 0.06324    |            |       |  0.58

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3959.00 ave        3959 max        3959 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125960.0 ave      125960 max      125960 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125960
Ave neighs/atom = 62.980000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.915402162049, Press = 0.630994749992577
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -17628.269   -17628.269   -17712.198   -17712.198     324.8137     324.8137    31831.786    31831.786    283.50754    283.50754 
   45000   -17623.834   -17623.834   -17711.278   -17711.278    338.41753    338.41753    31842.486    31842.486   -519.47131   -519.47131 
Loop time of 10.8487 on 1 procs for 1000 steps with 2000 atoms

Performance: 7.964 ns/day, 3.014 hours/ns, 92.177 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    | 10.298     | 10.298     | 10.298     |   0.0 | 94.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099878   | 0.099878   | 0.099878   |   0.0 |  0.92
Output  | 0.0001556  | 0.0001556  | 0.0001556  |   0.0 |  0.00
Modify  | 0.38885    | 0.38885    | 0.38885    |   0.0 |  3.58
Other   |            | 0.062      |            |       |  0.57

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4034.00 ave        4034 max        4034 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125934.0 ave      125934 max      125934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125934
Ave neighs/atom = 62.967000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.883072488954, Press = -0.71233088732886
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -17623.834   -17623.834   -17711.278   -17711.278    338.41753    338.41753    31842.486    31842.486   -519.47131   -519.47131 
   46000   -17622.514   -17622.514   -17709.538   -17709.538    336.79044    336.79044    31816.853    31816.853    2146.0163    2146.0163 
Loop time of 10.0535 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.594 ns/day, 2.793 hours/ns, 99.468 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    | 9.5472     | 9.5472     | 9.5472     |   0.0 | 94.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093495   | 0.093495   | 0.093495   |   0.0 |  0.93
Output  | 0.00015135 | 0.00015135 | 0.00015135 |   0.0 |  0.00
Modify  | 0.35203    | 0.35203    | 0.35203    |   0.0 |  3.50
Other   |            | 0.06061    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3966.00 ave        3966 max        3966 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125894.0 ave      125894 max      125894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125894
Ave neighs/atom = 62.947000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.860492541587, Press = 2.01080870373366
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -17622.514   -17622.514   -17709.538   -17709.538    336.79044    336.79044    31816.853    31816.853    2146.0163    2146.0163 
   47000   -17624.084   -17624.084   -17712.129   -17712.129    340.74286    340.74286    31820.193    31820.193    1586.0959    1586.0959 
Loop time of 10.1945 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.475 ns/day, 2.832 hours/ns, 98.092 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    | 9.6803     | 9.6803     | 9.6803     |   0.0 | 94.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095209   | 0.095209   | 0.095209   |   0.0 |  0.93
Output  | 0.00015173 | 0.00015173 | 0.00015173 |   0.0 |  0.00
Modify  | 0.35768    | 0.35768    | 0.35768    |   0.0 |  3.51
Other   |            | 0.06119    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4024.00 ave        4024 max        4024 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126056.0 ave      126056 max      126056 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126056
Ave neighs/atom = 63.028000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.86699890933, Press = -0.557255435190181
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000   -17624.084   -17624.084   -17712.129   -17712.129    340.74286    340.74286    31820.193    31820.193    1586.0959    1586.0959 
   48000   -17629.497   -17629.497   -17710.954   -17710.954    315.24677    315.24677    31868.525    31868.525   -3291.2002   -3291.2002 
Loop time of 10.1933 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.476 ns/day, 2.831 hours/ns, 98.104 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    | 9.6793     | 9.6793     | 9.6793     |   0.0 | 94.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094242   | 0.094242   | 0.094242   |   0.0 |  0.92
Output  | 0.00015757 | 0.00015757 | 0.00015757 |   0.0 |  0.00
Modify  | 0.35912    | 0.35912    | 0.35912    |   0.0 |  3.52
Other   |            | 0.06052    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4005.00 ave        4005 max        4005 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126040.0 ave      126040 max      126040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126040
Ave neighs/atom = 63.020000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.800071914109, Press = 0.264183217816121
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -17629.497   -17629.497   -17710.954   -17710.954    315.24677    315.24677    31868.525    31868.525   -3291.2002   -3291.2002 
   49000   -17623.885   -17623.885   -17710.737   -17710.737    336.12397    336.12397    31825.188    31825.188    437.62398    437.62398 
Loop time of 10.1961 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.474 ns/day, 2.832 hours/ns, 98.077 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    | 9.6798     | 9.6798     | 9.6798     |   0.0 | 94.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093845   | 0.093845   | 0.093845   |   0.0 |  0.92
Output  | 0.00015595 | 0.00015595 | 0.00015595 |   0.0 |  0.00
Modify  | 0.36104    | 0.36104    | 0.36104    |   0.0 |  3.54
Other   |            | 0.06131    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4002.00 ave        4002 max        4002 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125864.0 ave      125864 max      125864 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125864
Ave neighs/atom = 62.932000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.7415388247, Press = 0.714410809140656
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -17623.885   -17623.885   -17710.737   -17710.737    336.12397    336.12397    31825.188    31825.188    437.62398    437.62398 
   50000   -17621.991   -17621.991   -17709.753   -17709.753    339.64787    339.64787    31819.449    31819.449    1266.6699    1266.6699 
Loop time of 10.5883 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.160 ns/day, 2.941 hours/ns, 94.444 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    | 10.049     | 10.049     | 10.049     |   0.0 | 94.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097388   | 0.097388   | 0.097388   |   0.0 |  0.92
Output  | 0.00015512 | 0.00015512 | 0.00015512 |   0.0 |  0.00
Modify  | 0.37922    | 0.37922    | 0.37922    |   0.0 |  3.58
Other   |            | 0.0624     |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3999.00 ave        3999 max        3999 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125952.0 ave      125952 max      125952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125952
Ave neighs/atom = 62.976000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.712222231725, Press = -0.665333785862108
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -17621.991   -17621.991   -17709.753   -17709.753    339.64787    339.64787    31819.449    31819.449    1266.6699    1266.6699 
   51000   -17625.962   -17625.962   -17712.332   -17712.332    334.26086    334.26086    31816.419    31816.419    1682.8071    1682.8071 
Loop time of 10.4784 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.246 ns/day, 2.911 hours/ns, 95.434 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    | 9.9466     | 9.9466     | 9.9466     |   0.0 | 94.92
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097088   | 0.097088   | 0.097088   |   0.0 |  0.93
Output  | 0.00015548 | 0.00015548 | 0.00015548 |   0.0 |  0.00
Modify  | 0.37321    | 0.37321    | 0.37321    |   0.0 |  3.56
Other   |            | 0.06141    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4010.00 ave        4010 max        4010 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125914.0 ave      125914 max      125914 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125914
Ave neighs/atom = 62.957000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.765465896065, Press = 0.968212727111935
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -17625.962   -17625.962   -17712.332   -17712.332    334.26086    334.26086    31816.419    31816.419    1682.8071    1682.8071 
   52000   -17623.102   -17623.102   -17709.606   -17709.606     334.7775     334.7775    31793.092    31793.092    3523.3745    3523.3745 
Loop time of 10.2268 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.448 ns/day, 2.841 hours/ns, 97.782 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    | 9.7107     | 9.7107     | 9.7107     |   0.0 | 94.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093748   | 0.093748   | 0.093748   |   0.0 |  0.92
Output  | 0.00015327 | 0.00015327 | 0.00015327 |   0.0 |  0.00
Modify  | 0.36125    | 0.36125    | 0.36125    |   0.0 |  3.53
Other   |            | 0.06096    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3994.00 ave        3994 max        3994 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126022.0 ave      126022 max      126022 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126022
Ave neighs/atom = 63.011000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.769805056919, Press = -0.25783646007745
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -17623.102   -17623.102   -17709.606   -17709.606     334.7775     334.7775    31793.092    31793.092    3523.3745    3523.3745 
   53000    -17626.02    -17626.02   -17712.039   -17712.039    332.90309    332.90309    31834.088    31834.088   -290.99427   -290.99427 
Loop time of 10.084 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.568 ns/day, 2.801 hours/ns, 99.167 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    | 9.5755     | 9.5755     | 9.5755     |   0.0 | 94.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093539   | 0.093539   | 0.093539   |   0.0 |  0.93
Output  | 0.00019575 | 0.00019575 | 0.00019575 |   0.0 |  0.00
Modify  | 0.35445    | 0.35445    | 0.35445    |   0.0 |  3.52
Other   |            | 0.06025    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3974.00 ave        3974 max        3974 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125980.0 ave      125980 max      125980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125980
Ave neighs/atom = 62.990000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.707599931974, Press = -0.185089412263011
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000    -17626.02    -17626.02   -17712.039   -17712.039    332.90309    332.90309    31834.088    31834.088   -290.99427   -290.99427 
   54000   -17625.546   -17625.546   -17712.283   -17712.283    335.68357    335.68357    31841.263    31841.263   -1070.9726   -1070.9726 
Loop time of 10.5537 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.187 ns/day, 2.932 hours/ns, 94.754 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    | 10.023     | 10.023     | 10.023     |   0.0 | 94.97
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096243   | 0.096243   | 0.096243   |   0.0 |  0.91
Output  | 0.00015399 | 0.00015399 | 0.00015399 |   0.0 |  0.00
Modify  | 0.37235    | 0.37235    | 0.37235    |   0.0 |  3.53
Other   |            | 0.06206    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4003.00 ave        4003 max        4003 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125990.0 ave      125990 max      125990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125990
Ave neighs/atom = 62.995000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.667770975484, Press = -0.371792976339985
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -17625.546   -17625.546   -17712.283   -17712.283    335.68357    335.68357    31841.263    31841.263   -1070.9726   -1070.9726 
   55000   -17625.083   -17625.083    -17709.97    -17709.97    328.52205    328.52205    31823.775    31823.775    1065.4771    1065.4771 
Loop time of 10.0546 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.593 ns/day, 2.793 hours/ns, 99.457 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    | 9.5475     | 9.5475     | 9.5475     |   0.0 | 94.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092216   | 0.092216   | 0.092216   |   0.0 |  0.92
Output  | 0.00015563 | 0.00015563 | 0.00015563 |   0.0 |  0.00
Modify  | 0.35412    | 0.35412    | 0.35412    |   0.0 |  3.52
Other   |            | 0.06061    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3989.00 ave        3989 max        3989 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125924.0 ave      125924 max      125924 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125924
Ave neighs/atom = 62.962000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.648337025727, Press = -0.811945318341495
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -17625.083   -17625.083    -17709.97    -17709.97    328.52205    328.52205    31823.775    31823.775    1065.4771    1065.4771 
   56000   -17627.532   -17627.532   -17711.366   -17711.366    324.44663    324.44663      31860.9      31860.9   -2656.2558   -2656.2558 
Loop time of 10.3477 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.350 ns/day, 2.874 hours/ns, 96.640 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    | 9.8257     | 9.8257     | 9.8257     |   0.0 | 94.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094922   | 0.094922   | 0.094922   |   0.0 |  0.92
Output  | 0.00019516 | 0.00019516 | 0.00019516 |   0.0 |  0.00
Modify  | 0.36618    | 0.36618    | 0.36618    |   0.0 |  3.54
Other   |            | 0.06067    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3991.00 ave        3991 max        3991 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125970.0 ave      125970 max      125970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125970
Ave neighs/atom = 62.985000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.645186882627, Press = 0.397955847853139
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -17627.532   -17627.532   -17711.366   -17711.366    324.44663    324.44663      31860.9      31860.9   -2656.2558   -2656.2558 
   57000    -17626.75    -17626.75   -17712.047   -17712.047    330.10871    330.10871    31803.415    31803.415    2763.2488    2763.2488 
Loop time of 10.4851 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.240 ns/day, 2.913 hours/ns, 95.373 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    | 9.9517     | 9.9517     | 9.9517     |   0.0 | 94.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095281   | 0.095281   | 0.095281   |   0.0 |  0.91
Output  | 0.00015628 | 0.00015628 | 0.00015628 |   0.0 |  0.00
Modify  | 0.37619    | 0.37619    | 0.37619    |   0.0 |  3.59
Other   |            | 0.06173    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3980.00 ave        3980 max        3980 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125890.0 ave      125890 max      125890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125890
Ave neighs/atom = 62.945000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.559495217375, Press = 0.615033192403478
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000    -17626.75    -17626.75   -17712.047   -17712.047    330.10871    330.10871    31803.415    31803.415    2763.2488    2763.2488 
   58000   -17628.023   -17628.023   -17712.623   -17712.623    327.41165    327.41165    31837.341    31837.341   -380.34904   -380.34904 
Loop time of 10.5263 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.208 ns/day, 2.924 hours/ns, 95.000 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    | 9.9883     | 9.9883     | 9.9883     |   0.0 | 94.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097127   | 0.097127   | 0.097127   |   0.0 |  0.92
Output  | 0.00015471 | 0.00015471 | 0.00015471 |   0.0 |  0.00
Modify  | 0.37888    | 0.37888    | 0.37888    |   0.0 |  3.60
Other   |            | 0.06186    |            |       |  0.59

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4002.00 ave        4002 max        4002 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126040.0 ave      126040 max      126040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126040
Ave neighs/atom = 63.020000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.543481614595, Press = -0.453522361558908
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000   -17628.023   -17628.023   -17712.623   -17712.623    327.41165    327.41165    31837.341    31837.341   -380.34904   -380.34904 
   59000   -17625.107   -17625.107   -17709.881   -17709.881    328.08429    328.08429    31879.016    31879.016     -3751.06     -3751.06 
Loop time of 10.0703 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.580 ns/day, 2.797 hours/ns, 99.302 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5616     | 9.5616     | 9.5616     |   0.0 | 94.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093823   | 0.093823   | 0.093823   |   0.0 |  0.93
Output  | 0.00015468 | 0.00015468 | 0.00015468 |   0.0 |  0.00
Modify  | 0.35402    | 0.35402    | 0.35402    |   0.0 |  3.52
Other   |            | 0.06071    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4010.00 ave        4010 max        4010 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126036.0 ave      126036 max      126036 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126036
Ave neighs/atom = 63.018000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.538099014818, Press = -0.439002769151268
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -17625.107   -17625.107   -17709.881   -17709.881    328.08429    328.08429    31879.016    31879.016     -3751.06     -3751.06 
   60000   -17626.656   -17626.656   -17711.485   -17711.485    328.29764    328.29764    31844.178    31844.178   -507.07548   -507.07548 
Loop time of 10.1399 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.521 ns/day, 2.817 hours/ns, 98.621 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    | 9.6241     | 9.6241     | 9.6241     |   0.0 | 94.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094221   | 0.094221   | 0.094221   |   0.0 |  0.93
Output  | 0.00015413 | 0.00015413 | 0.00015413 |   0.0 |  0.00
Modify  | 0.35996    | 0.35996    | 0.35996    |   0.0 |  3.55
Other   |            | 0.06144    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3978.00 ave        3978 max        3978 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125782.0 ave      125782 max      125782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125782
Ave neighs/atom = 62.891000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.535465612616, Press = 0.512880969542038
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -17626.656   -17626.656   -17711.485   -17711.485    328.29764    328.29764    31844.178    31844.178   -507.07548   -507.07548 
   61000   -17623.725   -17623.725   -17710.957   -17710.957    337.59713    337.59713     31842.82     31842.82   -631.66721   -631.66721 
Loop time of 10.0729 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.577 ns/day, 2.798 hours/ns, 99.276 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    | 9.5634     | 9.5634     | 9.5634     |   0.0 | 94.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093106   | 0.093106   | 0.093106   |   0.0 |  0.92
Output  | 0.0001555  | 0.0001555  | 0.0001555  |   0.0 |  0.00
Modify  | 0.35496    | 0.35496    | 0.35496    |   0.0 |  3.52
Other   |            | 0.06128    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3975.00 ave        3975 max        3975 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125940.0 ave      125940 max      125940 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125940
Ave neighs/atom = 62.970000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.549459712845, Press = -0.111182224118113
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -17623.725   -17623.725   -17710.957   -17710.957    337.59713    337.59713     31842.82     31842.82   -631.66721   -631.66721 
   62000   -17624.405   -17624.405   -17709.893   -17709.893    330.85108    330.85108    31848.484    31848.484   -1457.0503   -1457.0503 
Loop time of 10.1591 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.505 ns/day, 2.822 hours/ns, 98.434 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    | 9.6452     | 9.6452     | 9.6452     |   0.0 | 94.94
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094469   | 0.094469   | 0.094469   |   0.0 |  0.93
Output  | 0.00015312 | 0.00015312 | 0.00015312 |   0.0 |  0.00
Modify  | 0.35775    | 0.35775    | 0.35775    |   0.0 |  3.52
Other   |            | 0.06146    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4019.00 ave        4019 max        4019 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125918.0 ave      125918 max      125918 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125918
Ave neighs/atom = 62.959000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.500656395191, Press = 0.0377820428483776
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -17624.405   -17624.405   -17709.893   -17709.893    330.85108    330.85108    31848.484    31848.484   -1457.0503   -1457.0503 
   63000   -17626.137   -17626.137   -17712.993   -17712.993    336.13858    336.13858    31841.934    31841.934   -841.48207   -841.48207 
Loop time of 10.0324 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.612 ns/day, 2.787 hours/ns, 99.677 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.5263     | 9.5263     | 9.5263     |   0.0 | 94.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.091877   | 0.091877   | 0.091877   |   0.0 |  0.92
Output  | 0.00015623 | 0.00015623 | 0.00015623 |   0.0 |  0.00
Modify  | 0.35321    | 0.35321    | 0.35321    |   0.0 |  3.52
Other   |            | 0.06083    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3959.00 ave        3959 max        3959 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125862.0 ave      125862 max      125862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125862
Ave neighs/atom = 62.931000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.477250260219, Press = 1.11186808444525
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -17626.137   -17626.137   -17712.993   -17712.993    336.13858    336.13858    31841.934    31841.934   -841.48207   -841.48207 
   64000   -17623.057   -17623.057   -17709.528   -17709.528    334.65153    334.65153     31799.61     31799.61    3309.3381    3309.3381 
Loop time of 10.0818 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.570 ns/day, 2.800 hours/ns, 99.189 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    | 9.5721     | 9.5721     | 9.5721     |   0.0 | 94.95
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092663   | 0.092663   | 0.092663   |   0.0 |  0.92
Output  | 0.00015417 | 0.00015417 | 0.00015417 |   0.0 |  0.00
Modify  | 0.35585    | 0.35585    | 0.35585    |   0.0 |  3.53
Other   |            | 0.06096    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3978.00 ave        3978 max        3978 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125952.0 ave      125952 max      125952 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125952
Ave neighs/atom = 62.976000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.471027219025, Press = 0.421012988002344
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -17623.057   -17623.057   -17709.528   -17709.528    334.65153    334.65153     31799.61     31799.61    3309.3381    3309.3381 
   65000   -17627.037   -17627.037   -17712.113   -17712.113     329.2555     329.2555    31854.532    31854.532   -1789.3948   -1789.3948 
Loop time of 10.0908 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.562 ns/day, 2.803 hours/ns, 99.100 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    | 9.5818     | 9.5818     | 9.5818     |   0.0 | 94.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093748   | 0.093748   | 0.093748   |   0.0 |  0.93
Output  | 0.00015574 | 0.00015574 | 0.00015574 |   0.0 |  0.00
Modify  | 0.35385    | 0.35385    | 0.35385    |   0.0 |  3.51
Other   |            | 0.06119    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4022.00 ave        4022 max        4022 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126020.0 ave      126020 max      126020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126020
Ave neighs/atom = 63.010000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.47122069848, Press = -0.505708827991227
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -17627.037   -17627.037   -17712.113   -17712.113     329.2555     329.2555    31854.532    31854.532   -1789.3948   -1789.3948 
   66000    -17624.07    -17624.07   -17709.752   -17709.752     331.5978     331.5978    31859.114    31859.114   -1927.8997   -1927.8997 
Loop time of 10.0613 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.587 ns/day, 2.795 hours/ns, 99.391 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 9.554      | 9.554      | 9.554      |   0.0 | 94.96
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093378   | 0.093378   | 0.093378   |   0.0 |  0.93
Output  | 0.00015504 | 0.00015504 | 0.00015504 |   0.0 |  0.00
Modify  | 0.35277    | 0.35277    | 0.35277    |   0.0 |  3.51
Other   |            | 0.06101    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3995.00 ave        3995 max        3995 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125910.0 ave      125910 max      125910 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125910
Ave neighs/atom = 62.955000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.443695346154, Press = 0.18015921197749
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000    -17624.07    -17624.07   -17709.752   -17709.752     331.5978     331.5978    31859.114    31859.114   -1927.8997   -1927.8997 
   67000    -17626.35    -17626.35   -17711.816   -17711.816    330.76243    330.76243    31846.698    31846.698   -936.30102   -936.30102 
Loop time of 10.5584 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.183 ns/day, 2.933 hours/ns, 94.712 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    | 10.021     | 10.021     | 10.021     |   0.0 | 94.91
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096419   | 0.096419   | 0.096419   |   0.0 |  0.91
Output  | 0.00015533 | 0.00015533 | 0.00015533 |   0.0 |  0.00
Modify  | 0.37922    | 0.37922    | 0.37922    |   0.0 |  3.59
Other   |            | 0.06146    |            |       |  0.58

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3946.00 ave        3946 max        3946 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125888.0 ave      125888 max      125888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125888
Ave neighs/atom = 62.944000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.389478948952, Press = 0.959079327964824
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000    -17626.35    -17626.35   -17711.816   -17711.816    330.76243    330.76243    31846.698    31846.698   -936.30102   -936.30102 
   68000    -17627.51    -17627.51   -17712.544   -17712.544    329.08781    329.08781    31824.453    31824.453    766.42378    766.42378 
Loop time of 10.0947 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.559 ns/day, 2.804 hours/ns, 99.062 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    | 9.5872     | 9.5872     | 9.5872     |   0.0 | 94.97
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09252    | 0.09252    | 0.09252    |   0.0 |  0.92
Output  | 0.00015485 | 0.00015485 | 0.00015485 |   0.0 |  0.00
Modify  | 0.35357    | 0.35357    | 0.35357    |   0.0 |  3.50
Other   |            | 0.06118    |            |       |  0.61

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        3994.00 ave        3994 max        3994 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125986.0 ave      125986 max      125986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 125986
Ave neighs/atom = 62.993000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.373296069079, Press = 0.0921309850895138
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000    -17627.51    -17627.51   -17712.544   -17712.544    329.08781    329.08781    31824.453    31824.453    766.42378    766.42378 
   69000   -17624.955   -17624.955   -17712.021   -17712.021     336.9533     336.9533    31836.738    31836.738   -134.51823   -134.51823 
Loop time of 10.1885 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.480 ns/day, 2.830 hours/ns, 98.150 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    | 9.6716     | 9.6716     | 9.6716     |   0.0 | 94.93
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095046   | 0.095046   | 0.095046   |   0.0 |  0.93
Output  | 0.0001981  | 0.0001981  | 0.0001981  |   0.0 |  0.00
Modify  | 0.36023    | 0.36023    | 0.36023    |   0.0 |  3.54
Other   |            | 0.06141    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4005.00 ave        4005 max        4005 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      126034.0 ave      126034 max      126034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 126034
Ave neighs/atom = 63.017000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.353944685894, Press = 0.73468492209211
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.403
  ghost atom cutoff = 6.403
  binsize = 3.2015, bins = 10 10 10
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.403
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.754 | 3.754 | 3.754 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -17624.955   -17624.955   -17712.021   -17712.021     336.9533     336.9533    31836.738    31836.738   -134.51823   -134.51823 
   70000   -17631.997   -17631.997   -17714.404   -17714.404    318.92414    318.92414    31793.231    31793.231    2592.5441    2592.5441 
Loop time of 10.5319 on 1 procs for 1000 steps with 2000 atoms

Performance: 8.204 ns/day, 2.926 hours/ns, 94.950 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    | 9.9936     | 9.9936     | 9.9936     |   0.0 | 94.89
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096949   | 0.096949   | 0.096949   |   0.0 |  0.92
Output  | 0.00015445 | 0.00015445 | 0.00015445 |   0.0 |  0.00
Modify  | 0.37834    | 0.37834    | 0.37834    |   0.0 |  3.59
Other   |            | 0.06282    |            |       |  0.60

Nlocal:        2000.00 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:        4008.00 ave        4008 max        4008 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:         0.00000 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:      125970.0 ave      125970 max      125970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0