# 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.917371571063995*${_u_distance}
variable latticeconst_converted equal 3.917371571063995*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.91737157106399
Lattice spacing in x,y,z = 3.9173716 3.9173716 3.9173716
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 (39.173716 39.173716 39.173716)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0.0000000 0.0000000 0.0000000) to (39.173716 39.173716 39.173716)
  create_atoms CPU = 0.004 seconds

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

kim_interactions Pt

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

kim interactions Pt
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimSeolJi_2017_PtV__MO_912978207512_001
pair_coeff * * Pt
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 195.078

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
       0   -22918.129   -22918.129       -23080       -23080       313.15       313.15    60115.201    60115.201    2876.0657    2876.0657 
    1000   -22748.002   -22748.002   -22919.059   -22919.059    330.92187    330.92187    60739.134    60739.134   -2735.3144   -2735.3144 
Loop time of 185.027 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.467 ns/day, 51.396 hours/ns, 5.405 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    | 184.1      | 184.1      | 184.1      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15156    | 0.15156    | 0.15156    |   0.0 |  0.08
Output  | 0.00028142 | 0.00028142 | 0.00028142 |   0.0 |  0.00
Modify  | 0.67758    | 0.67758    | 0.67758    |   0.0 |  0.37
Other   |            | 0.09851    |            |       |  0.05

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

Total # of neighbors = 312000
Ave neighs/atom = 78.000000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    1000   -22748.002   -22748.002   -22919.059   -22919.059    330.92187    330.92187    60739.134    60739.134   -2735.3144   -2735.3144 
    2000    -22756.51    -22756.51   -22923.269   -22923.269    322.60775    322.60775     60686.67     60686.67   -1067.3126   -1067.3126 
Loop time of 201.375 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.938 hours/ns, 4.966 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    | 200.43     | 200.43     | 200.43     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15123    | 0.15123    | 0.15123    |   0.0 |  0.08
Output  | 0.00021001 | 0.00021001 | 0.00021001 |   0.0 |  0.00
Modify  | 0.69562    | 0.69562    | 0.69562    |   0.0 |  0.35
Other   |            | 0.1017     |            |       |  0.05

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

Total # of neighbors = 311938
Ave neighs/atom = 77.984500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    2000    -22756.51    -22756.51   -22923.269   -22923.269    322.60775    322.60775     60686.67     60686.67   -1067.3126   -1067.3126 
    3000   -22758.464   -22758.464   -22923.823   -22923.823    319.89695    319.89695    60691.549    60691.549   -1433.6629   -1433.6629 
Loop time of 205.872 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.187 hours/ns, 4.857 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    | 204.9      | 204.9      | 204.9      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15425    | 0.15425    | 0.15425    |   0.0 |  0.07
Output  | 0.00032141 | 0.00032141 | 0.00032141 |   0.0 |  0.00
Modify  | 0.71218    | 0.71218    | 0.71218    |   0.0 |  0.35
Other   |            | 0.1011     |            |       |  0.05

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

Total # of neighbors = 311970
Ave neighs/atom = 77.992500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    3000   -22758.464   -22758.464   -22923.823   -22923.823    319.89695    319.89695    60691.549    60691.549   -1433.6629   -1433.6629 
    4000   -22753.324   -22753.324   -22920.512   -22920.512    323.43652    323.43652    60628.318    60628.318    2311.0212    2311.0212 
Loop time of 200.993 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.831 hours/ns, 4.975 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 200.05     | 200.05     | 200.05     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15154    | 0.15154    | 0.15154    |   0.0 |  0.08
Output  | 0.00021389 | 0.00021389 | 0.00021389 |   0.0 |  0.00
Modify  | 0.69238    | 0.69238    | 0.69238    |   0.0 |  0.34
Other   |            | 0.101      |            |       |  0.05

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

Total # of neighbors = 311954
Ave neighs/atom = 77.988500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    4000   -22753.324   -22753.324   -22920.512   -22920.512    323.43652    323.43652    60628.318    60628.318    2311.0212    2311.0212 
    5000   -22758.552   -22758.552   -22917.089   -22917.089    306.70073    306.70073    60714.536    60714.536   -1675.9861   -1675.9861 
Loop time of 202.206 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.168 hours/ns, 4.945 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    | 201.26     | 201.26     | 201.26     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15195    | 0.15195    | 0.15195    |   0.0 |  0.08
Output  | 0.00017848 | 0.00017848 | 0.00017848 |   0.0 |  0.00
Modify  | 0.69332    | 0.69332    | 0.69332    |   0.0 |  0.34
Other   |            | 0.1013     |            |       |  0.05

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

Total # of neighbors = 311968
Ave neighs/atom = 77.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 = 316.113305788184, Press = 504.948448318981
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    5000   -22758.552   -22758.552   -22917.089   -22917.089    306.70073    306.70073    60714.536    60714.536   -1675.9861   -1675.9861 
    6000   -22757.807   -22757.807   -22921.574   -22921.574    316.81813    316.81813     60618.93     60618.93    2344.1858    2344.1858 
Loop time of 203.792 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.609 hours/ns, 4.907 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    | 202.81     | 202.81     | 202.81     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15406    | 0.15406    | 0.15406    |   0.0 |  0.08
Output  | 0.00017688 | 0.00017688 | 0.00017688 |   0.0 |  0.00
Modify  | 0.72738    | 0.72738    | 0.72738    |   0.0 |  0.36
Other   |            | 0.1005     |            |       |  0.05

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

Total # of neighbors = 311930
Ave neighs/atom = 77.982500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.585576361303, Press = 42.2740505628763
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    6000   -22757.807   -22757.807   -22921.574   -22921.574    316.81813    316.81813     60618.93     60618.93    2344.1858    2344.1858 
    7000   -22754.957   -22754.957    -22917.17    -22917.17     313.8125     313.8125    60693.822    60693.822   -615.57647   -615.57647 
Loop time of 205.479 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.078 hours/ns, 4.867 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    | 204.49     | 204.49     | 204.49     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1548     | 0.1548     | 0.1548     |   0.0 |  0.08
Output  | 0.00027956 | 0.00027956 | 0.00027956 |   0.0 |  0.00
Modify  | 0.73584    | 0.73584    | 0.73584    |   0.0 |  0.36
Other   |            | 0.1011     |            |       |  0.05

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

Total # of neighbors = 311958
Ave neighs/atom = 77.989500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.987105902589, Press = 10.0552510307562
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    7000   -22754.957   -22754.957    -22917.17    -22917.17     313.8125     313.8125    60693.822    60693.822   -615.57647   -615.57647 
    8000   -22757.677   -22757.677   -22919.102   -22919.102    312.28789    312.28789    60670.182    60670.182    333.63706    333.63706 
Loop time of 206.761 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.434 hours/ns, 4.836 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    | 205.76     | 205.76     | 205.76     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15519    | 0.15519    | 0.15519    |   0.0 |  0.08
Output  | 0.00017804 | 0.00017804 | 0.00017804 |   0.0 |  0.00
Modify  | 0.74482    | 0.74482    | 0.74482    |   0.0 |  0.36
Other   |            | 0.1023     |            |       |  0.05

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

Total # of neighbors = 311908
Ave neighs/atom = 77.977000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.311443685434, Press = 9.16111654090467
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    8000   -22757.677   -22757.677   -22919.102   -22919.102    312.28789    312.28789    60670.182    60670.182    333.63706    333.63706 
    9000   -22757.264   -22757.264   -22920.489   -22920.489    315.76861    315.76861    60654.296    60654.296    802.70713    802.70713 
Loop time of 204.926 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.924 hours/ns, 4.880 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    | 203.93     | 203.93     | 203.93     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1547     | 0.1547     | 0.1547     |   0.0 |  0.08
Output  | 0.0002832  | 0.0002832  | 0.0002832  |   0.0 |  0.00
Modify  | 0.73903    | 0.73903    | 0.73903    |   0.0 |  0.36
Other   |            | 0.1023     |            |       |  0.05

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

Total # of neighbors = 311968
Ave neighs/atom = 77.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 = 313.150126664382, Press = 13.7274084010307
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
    9000   -22757.264   -22757.264   -22920.489   -22920.489    315.76861    315.76861    60654.296    60654.296    802.70713    802.70713 
   10000   -22760.123   -22760.123   -22919.311   -22919.311    307.96035    307.96035     60659.84     60659.84    654.19953    654.19953 
Loop time of 204.933 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.926 hours/ns, 4.880 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    | 203.94     | 203.94     | 203.94     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15441    | 0.15441    | 0.15441    |   0.0 |  0.08
Output  | 0.00019651 | 0.00019651 | 0.00019651 |   0.0 |  0.00
Modify  | 0.73745    | 0.73745    | 0.73745    |   0.0 |  0.36
Other   |            | 0.1017     |            |       |  0.05

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

Total # of neighbors = 311942
Ave neighs/atom = 77.985500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.074919233605, Press = 0.317876374692098
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   10000   -22760.123   -22760.123   -22919.311   -22919.311    307.96035    307.96035     60659.84     60659.84    654.19953    654.19953 
   11000   -22761.686   -22761.686   -22921.095   -22921.095    308.38699    308.38699    60709.435    60709.435   -1823.4414   -1823.4414 
Loop time of 203.656 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.571 hours/ns, 4.910 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    | 202.67     | 202.67     | 202.67     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15349    | 0.15349    | 0.15349    |   0.0 |  0.08
Output  | 0.00024953 | 0.00024953 | 0.00024953 |   0.0 |  0.00
Modify  | 0.73573    | 0.73573    | 0.73573    |   0.0 |  0.36
Other   |            | 0.1012     |            |       |  0.05

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

Total # of neighbors = 311980
Ave neighs/atom = 77.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 = 312.730091637388, Press = 2.33225516550776
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   11000   -22761.686   -22761.686   -22921.095   -22921.095    308.38699    308.38699    60709.435    60709.435   -1823.4414   -1823.4414 
   12000   -22756.204   -22756.204   -22918.314   -22918.314    313.61414    313.61414    60680.399    60680.399   -42.146907   -42.146907 
Loop time of 203.895 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.637 hours/ns, 4.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    | 202.9      | 202.9      | 202.9      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15408    | 0.15408    | 0.15408    |   0.0 |  0.08
Output  | 0.00017774 | 0.00017774 | 0.00017774 |   0.0 |  0.00
Modify  | 0.73845    | 0.73845    | 0.73845    |   0.0 |  0.36
Other   |            | 0.1012     |            |       |  0.05

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

Total # of neighbors = 311948
Ave neighs/atom = 77.987000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.686369171916, Press = 5.81898115177133
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   12000   -22756.204   -22756.204   -22918.314   -22918.314    313.61414    313.61414    60680.399    60680.399   -42.146907   -42.146907 
   13000   -22755.554   -22755.554   -22920.522   -22920.522    319.14146    319.14146    60682.739    60682.739   -423.84341   -423.84341 
Loop time of 204.023 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.673 hours/ns, 4.901 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    | 203.03     | 203.03     | 203.03     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15405    | 0.15405    | 0.15405    |   0.0 |  0.08
Output  | 0.00022198 | 0.00022198 | 0.00022198 |   0.0 |  0.00
Modify  | 0.73737    | 0.73737    | 0.73737    |   0.0 |  0.36
Other   |            | 0.1008     |            |       |  0.05

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

Total # of neighbors = 311942
Ave neighs/atom = 77.985500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.54381859584, Press = 7.32229739831873
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   13000   -22755.554   -22755.554   -22920.522   -22920.522    319.14146    319.14146    60682.739    60682.739   -423.84341   -423.84341 
   14000   -22758.121   -22758.121   -22922.429   -22922.429    317.86664    317.86664    60657.097    60657.097    429.36087    429.36087 
Loop time of 206.623 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.395 hours/ns, 4.840 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    | 205.62     | 205.62     | 205.62     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15445    | 0.15445    | 0.15445    |   0.0 |  0.07
Output  | 0.00017592 | 0.00017592 | 0.00017592 |   0.0 |  0.00
Modify  | 0.74932    | 0.74932    | 0.74932    |   0.0 |  0.36
Other   |            | 0.1017     |            |       |  0.05

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

Total # of neighbors = 311954
Ave neighs/atom = 77.988500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.818138370279, Press = 3.15334973073111
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   14000   -22758.121   -22758.121   -22922.429   -22922.429    317.86664    317.86664    60657.097    60657.097    429.36087    429.36087 
   15000   -22753.461   -22753.461   -22915.001   -22915.001    312.51115    312.51115     60685.74     60685.74    151.29489    151.29489 
Loop time of 204.06 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.683 hours/ns, 4.901 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    | 203.07     | 203.07     | 203.07     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15344    | 0.15344    | 0.15344    |   0.0 |  0.08
Output  | 0.0004842  | 0.0004842  | 0.0004842  |   0.0 |  0.00
Modify  | 0.73413    | 0.73413    | 0.73413    |   0.0 |  0.36
Other   |            | 0.1017     |            |       |  0.05

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

Total # of neighbors = 311972
Ave neighs/atom = 77.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 = 312.887128344259, Press = 2.49739366331449
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   15000   -22753.461   -22753.461   -22915.001   -22915.001    312.51115    312.51115     60685.74     60685.74    151.29489    151.29489 
   16000   -22756.839   -22756.839   -22916.813   -22916.813    309.47983    309.47983    60665.605    60665.605    758.71883    758.71883 
Loop time of 203.043 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.401 hours/ns, 4.925 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    | 202.06     | 202.06     | 202.06     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.154      | 0.154      | 0.154      |   0.0 |  0.08
Output  | 0.00025005 | 0.00025005 | 0.00025005 |   0.0 |  0.00
Modify  | 0.73146    | 0.73146    | 0.73146    |   0.0 |  0.36
Other   |            | 0.1013     |            |       |  0.05

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

Total # of neighbors = 311966
Ave neighs/atom = 77.991500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.045730068975, Press = 2.69148471342926
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   16000   -22756.839   -22756.839   -22916.813   -22916.813    309.47983    309.47983    60665.605    60665.605    758.71883    758.71883 
   17000   -22760.212   -22760.212    -22919.58    -22919.58    308.30753    308.30753    60648.111    60648.111    1152.5014    1152.5014 
Loop time of 203.443 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.512 hours/ns, 4.915 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    | 202.45     | 202.45     | 202.45     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15534    | 0.15534    | 0.15534    |   0.0 |  0.08
Output  | 0.00023058 | 0.00023058 | 0.00023058 |   0.0 |  0.00
Modify  | 0.73566    | 0.73566    | 0.73566    |   0.0 |  0.36
Other   |            | 0.1015     |            |       |  0.05

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

Total # of neighbors = 311952
Ave neighs/atom = 77.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.927979870264, Press = 4.33471689871723
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   17000   -22760.212   -22760.212    -22919.58    -22919.58    308.30753    308.30753    60648.111    60648.111    1152.5014    1152.5014 
   18000   -22756.336   -22756.336    -22917.07    -22917.07    310.95063    310.95063    60650.273    60650.273    1450.4467    1450.4467 
Loop time of 202.595 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.276 hours/ns, 4.936 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    | 201.61     | 201.61     | 201.61     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15329    | 0.15329    | 0.15329    |   0.0 |  0.08
Output  | 0.00017467 | 0.00017467 | 0.00017467 |   0.0 |  0.00
Modify  | 0.72931    | 0.72931    | 0.72931    |   0.0 |  0.36
Other   |            | 0.1012     |            |       |  0.05

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

Total # of neighbors = 311964
Ave neighs/atom = 77.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.918891390452, Press = 0.995081409343263
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   18000   -22756.336   -22756.336    -22917.07    -22917.07    310.95063    310.95063    60650.273    60650.273    1450.4467    1450.4467 
   19000   -22758.597   -22758.597   -22920.209   -22920.209    312.64911    312.64911    60747.275    60747.275   -3430.9521   -3430.9521 
Loop time of 203.359 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.489 hours/ns, 4.917 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    | 202.38     | 202.38     | 202.38     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15311    | 0.15311    | 0.15311    |   0.0 |  0.08
Output  | 0.0001759  | 0.0001759  | 0.0001759  |   0.0 |  0.00
Modify  | 0.72675    | 0.72675    | 0.72675    |   0.0 |  0.36
Other   |            | 0.1008     |            |       |  0.05

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

Total # of neighbors = 311978
Ave neighs/atom = 77.994500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.95014308637, Press = 2.74130246445988
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   19000   -22758.597   -22758.597   -22920.209   -22920.209    312.64911    312.64911    60747.275    60747.275   -3430.9521   -3430.9521 
   20000   -22765.302   -22765.302   -22923.638   -22923.638    306.31317    306.31317    60626.271    60626.271    1745.7417    1745.7417 
Loop time of 205.969 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.419 ns/day, 57.214 hours/ns, 4.855 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    | 204.96     | 204.96     | 204.96     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15529    | 0.15529    | 0.15529    |   0.0 |  0.08
Output  | 0.0001739  | 0.0001739  | 0.0001739  |   0.0 |  0.00
Modify  | 0.74857    | 0.74857    | 0.74857    |   0.0 |  0.36
Other   |            | 0.1023     |            |       |  0.05

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

Total # of neighbors = 311936
Ave neighs/atom = 77.984000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.782117726039, Press = 1.75780060313051
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   20000   -22765.302   -22765.302   -22923.638   -22923.638    306.31317    306.31317    60626.271    60626.271    1745.7417    1745.7417 
   21000   -22756.405   -22756.405   -22919.553   -22919.553    315.62012    315.62012    60634.617    60634.617    1890.3994    1890.3994 
Loop time of 203.808 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.613 hours/ns, 4.907 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    | 202.81     | 202.81     | 202.81     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1554     | 0.1554     | 0.1554     |   0.0 |  0.08
Output  | 0.00018018 | 0.00018018 | 0.00018018 |   0.0 |  0.00
Modify  | 0.73863    | 0.73863    | 0.73863    |   0.0 |  0.36
Other   |            | 0.1019     |            |       |  0.05

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

Total # of neighbors = 311964
Ave neighs/atom = 77.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.763814600103, Press = 3.25666046862445
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   21000   -22756.405   -22756.405   -22919.553   -22919.553    315.62012    315.62012    60634.617    60634.617    1890.3994    1890.3994 
   22000   -22756.523   -22756.523   -22918.277   -22918.277    312.92349    312.92349    60630.193    60630.193    2317.3939    2317.3939 
Loop time of 203.675 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.577 hours/ns, 4.910 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    | 202.69     | 202.69     | 202.69     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15276    | 0.15276    | 0.15276    |   0.0 |  0.08
Output  | 0.00022036 | 0.00022036 | 0.00022036 |   0.0 |  0.00
Modify  | 0.72759    | 0.72759    | 0.72759    |   0.0 |  0.36
Other   |            | 0.1009     |            |       |  0.05

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

Total # of neighbors = 311962
Ave neighs/atom = 77.990500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.729325421255, Press = 2.549274318963
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   22000   -22756.523   -22756.523   -22918.277   -22918.277    312.92349    312.92349    60630.193    60630.193    2317.3939    2317.3939 
   23000   -22756.214   -22756.214    -22918.13    -22918.13     313.2362     313.2362    60694.378    60694.378   -670.48971   -670.48971 
Loop time of 204.264 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.740 hours/ns, 4.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    | 203.27     | 203.27     | 203.27     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1537     | 0.1537     | 0.1537     |   0.0 |  0.08
Output  | 0.00022804 | 0.00022804 | 0.00022804 |   0.0 |  0.00
Modify  | 0.73749    | 0.73749    | 0.73749    |   0.0 |  0.36
Other   |            | 0.102      |            |       |  0.05

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

Total # of neighbors = 311962
Ave neighs/atom = 77.990500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.687241967912, Press = 1.341316743868
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   23000   -22756.214   -22756.214    -22918.13    -22918.13     313.2362     313.2362    60694.378    60694.378   -670.48971   -670.48971 
   24000   -22757.579   -22757.579   -22919.431   -22919.431     313.1153     313.1153    60711.641    60711.641   -1750.5961   -1750.5961 
Loop time of 203.064 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.407 hours/ns, 4.925 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    | 202.08     | 202.08     | 202.08     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15191    | 0.15191    | 0.15191    |   0.0 |  0.07
Output  | 0.00021554 | 0.00021554 | 0.00021554 |   0.0 |  0.00
Modify  | 0.73354    | 0.73354    | 0.73354    |   0.0 |  0.36
Other   |            | 0.1017     |            |       |  0.05

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

Total # of neighbors = 311948
Ave neighs/atom = 77.987000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.701443701924, Press = 0.561838815131803
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   24000   -22757.579   -22757.579   -22919.431   -22919.431     313.1153     313.1153    60711.641    60711.641   -1750.5961   -1750.5961 
   25000   -22756.686   -22756.686   -22917.118   -22917.118    310.36619    310.36619    60632.683    60632.683    2287.3868    2287.3868 
Loop time of 201.128 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.869 hours/ns, 4.972 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    | 200.16     | 200.16     | 200.16     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1514     | 0.1514     | 0.1514     |   0.0 |  0.08
Output  | 0.00017619 | 0.00017619 | 0.00017619 |   0.0 |  0.00
Modify  | 0.71937    | 0.71937    | 0.71937    |   0.0 |  0.36
Other   |            | 0.1001     |            |       |  0.05

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

Total # of neighbors = 311948
Ave neighs/atom = 77.987000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.818495961238, Press = 2.18539195112391
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   25000   -22756.686   -22756.686   -22917.118   -22917.118    310.36619    310.36619    60632.683    60632.683    2287.3868    2287.3868 
   26000   -22754.426   -22754.426   -22918.576   -22918.576    317.55962    317.55962    60692.828    60692.828   -564.72642   -564.72642 
Loop time of 205.554 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.098 hours/ns, 4.865 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    | 204.55     | 204.55     | 204.55     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15512    | 0.15512    | 0.15512    |   0.0 |  0.08
Output  | 0.00020597 | 0.00020597 | 0.00020597 |   0.0 |  0.00
Modify  | 0.74157    | 0.74157    | 0.74157    |   0.0 |  0.36
Other   |            | 0.1032     |            |       |  0.05

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

Total # of neighbors = 311980
Ave neighs/atom = 77.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 = 312.852438584679, Press = -0.592782718034109
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   26000   -22754.426   -22754.426   -22918.576   -22918.576    317.55962    317.55962    60692.828    60692.828   -564.72642   -564.72642 
   27000   -22761.939   -22761.939   -22923.614   -22923.614    312.77131    312.77131    60668.626    60668.626   -254.61646   -254.61646 
Loop time of 206.833 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.454 hours/ns, 4.835 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    | 205.83     | 205.83     | 205.83     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15533    | 0.15533    | 0.15533    |   0.0 |  0.08
Output  | 0.00017724 | 0.00017724 | 0.00017724 |   0.0 |  0.00
Modify  | 0.74899    | 0.74899    | 0.74899    |   0.0 |  0.36
Other   |            | 0.1031     |            |       |  0.05

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

Total # of neighbors = 311958
Ave neighs/atom = 77.989500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.86743635708, Press = 2.7841854951076
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   27000   -22761.939   -22761.939   -22923.614   -22923.614    312.77131    312.77131    60668.626    60668.626   -254.61646   -254.61646 
   28000   -22755.745   -22755.745   -22917.686   -22917.686    313.28546    313.28546    60673.058    60673.058     238.6984     238.6984 
Loop time of 201.028 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.841 hours/ns, 4.974 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    | 200.06     | 200.06     | 200.06     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15159    | 0.15159    | 0.15159    |   0.0 |  0.08
Output  | 0.00022981 | 0.00022981 | 0.00022981 |   0.0 |  0.00
Modify  | 0.71868    | 0.71868    | 0.71868    |   0.0 |  0.36
Other   |            | 0.09982    |            |       |  0.05

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

Total # of neighbors = 311970
Ave neighs/atom = 77.992500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.851218202988, Press = 1.44044172716502
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   28000   -22755.745   -22755.745   -22917.686   -22917.686    313.28546    313.28546    60673.058    60673.058     238.6984     238.6984 
   29000    -22757.94    -22757.94   -22917.326   -22917.326    308.34267    308.34267    60670.688    60670.688    385.24062    385.24062 
Loop time of 201.302 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.917 hours/ns, 4.968 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    | 200.33     | 200.33     | 200.33     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15141    | 0.15141    | 0.15141    |   0.0 |  0.08
Output  | 0.00017959 | 0.00017959 | 0.00017959 |   0.0 |  0.00
Modify  | 0.71858    | 0.71858    | 0.71858    |   0.0 |  0.36
Other   |            | 0.1009     |            |       |  0.05

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

Total # of neighbors = 311972
Ave neighs/atom = 77.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 = 312.771789068364, Press = -0.512471499247483
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   29000    -22757.94    -22757.94   -22917.326   -22917.326    308.34267    308.34267    60670.688    60670.688    385.24062    385.24062 
   30000   -22758.773   -22758.773   -22918.222   -22918.222    308.46378    308.46378    60640.053    60640.053    1673.3235    1673.3235 
Loop time of 203.365 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.490 hours/ns, 4.917 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    | 202.38     | 202.38     | 202.38     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15195    | 0.15195    | 0.15195    |   0.0 |  0.07
Output  | 0.00023318 | 0.00023318 | 0.00023318 |   0.0 |  0.00
Modify  | 0.72883    | 0.72883    | 0.72883    |   0.0 |  0.36
Other   |            | 0.1028     |            |       |  0.05

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

Total # of neighbors = 311944
Ave neighs/atom = 77.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 = 312.774959008424, Press = 3.0910455599743
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   30000   -22758.773   -22758.773   -22918.222   -22918.222    308.46378    308.46378    60640.053    60640.053    1673.3235    1673.3235 
   31000   -22752.985   -22752.985   -22917.187   -22917.187    317.66024    317.66024    60673.602    60673.602    385.08167    385.08167 
Loop time of 201.929 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.091 hours/ns, 4.952 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    | 200.95     | 200.95     | 200.95     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15279    | 0.15279    | 0.15279    |   0.0 |  0.08
Output  | 0.00017533 | 0.00017533 | 0.00017533 |   0.0 |  0.00
Modify  | 0.72322    | 0.72322    | 0.72322    |   0.0 |  0.36
Other   |            | 0.1009     |            |       |  0.05

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

Total # of neighbors = 311928
Ave neighs/atom = 77.982000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.752892668828, Press = 0.676584476165088
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   31000   -22752.985   -22752.985   -22917.187   -22917.187    317.66024    317.66024    60673.602    60673.602    385.08167    385.08167 
   32000   -22759.284   -22759.284   -22922.806   -22922.806    316.34419    316.34419    60702.504    60702.504   -1684.8917   -1684.8917 
Loop time of 202.363 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.212 hours/ns, 4.942 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    | 201.38     | 201.38     | 201.38     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15255    | 0.15255    | 0.15255    |   0.0 |  0.08
Output  | 0.00017417 | 0.00017417 | 0.00017417 |   0.0 |  0.00
Modify  | 0.72602    | 0.72602    | 0.72602    |   0.0 |  0.36
Other   |            | 0.1008     |            |       |  0.05

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

Total # of neighbors = 311960
Ave neighs/atom = 77.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 = 312.823705676481, Press = 1.45793824155101
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   32000   -22759.284   -22759.284   -22922.806   -22922.806    316.34419    316.34419    60702.504    60702.504   -1684.8917   -1684.8917 
   33000   -22757.177   -22757.177   -22920.715   -22920.715    316.37573    316.37573    60637.202    60637.202    1667.6572    1667.6572 
Loop time of 201.616 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 56.005 hours/ns, 4.960 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    | 200.63     | 200.63     | 200.63     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15247    | 0.15247    | 0.15247    |   0.0 |  0.08
Output  | 0.00017433 | 0.00017433 | 0.00017433 |   0.0 |  0.00
Modify  | 0.72764    | 0.72764    | 0.72764    |   0.0 |  0.36
Other   |            | 0.1011     |            |       |  0.05

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

Total # of neighbors = 311970
Ave neighs/atom = 77.992500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.834689309531, Press = 0.679352806799566
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   33000   -22757.177   -22757.177   -22920.715   -22920.715    316.37573    316.37573    60637.202    60637.202    1667.6572    1667.6572 
   34000   -22756.936   -22756.936   -22917.846   -22917.846    311.29195    311.29195    60729.204    60729.204   -2324.5974   -2324.5974 
Loop time of 202.071 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.131 hours/ns, 4.949 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    | 201.08     | 201.08     | 201.08     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15332    | 0.15332    | 0.15332    |   0.0 |  0.08
Output  | 0.00018132 | 0.00018132 | 0.00018132 |   0.0 |  0.00
Modify  | 0.73113    | 0.73113    | 0.73113    |   0.0 |  0.36
Other   |            | 0.1015     |            |       |  0.05

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

Total # of neighbors = 311944
Ave neighs/atom = 77.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 = 312.813248513213, Press = 1.78677144682286
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   34000   -22756.936   -22756.936   -22917.846   -22917.846    311.29195    311.29195    60729.204    60729.204   -2324.5974   -2324.5974 
   35000   -22753.846   -22753.846   -22918.747   -22918.747    319.01217    319.01217    60646.135    60646.135    1616.0982    1616.0982 
Loop time of 202.196 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.166 hours/ns, 4.946 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    | 201.21     | 201.21     | 201.21     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15245    | 0.15245    | 0.15245    |   0.0 |  0.08
Output  | 0.00017346 | 0.00017346 | 0.00017346 |   0.0 |  0.00
Modify  | 0.72857    | 0.72857    | 0.72857    |   0.0 |  0.36
Other   |            | 0.102      |            |       |  0.05

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

Total # of neighbors = 311948
Ave neighs/atom = 77.987000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.87175679341, Press = 2.45393106421732
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   35000   -22753.846   -22753.846   -22918.747   -22918.747    319.01217    319.01217    60646.135    60646.135    1616.0982    1616.0982 
   36000   -22759.403   -22759.403   -22918.423   -22918.423    307.63442    307.63442    60659.801    60659.801    829.41794    829.41794 
Loop time of 197.586 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.885 hours/ns, 5.061 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    | 196.63     | 196.63     | 196.63     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14875    | 0.14875    | 0.14875    |   0.0 |  0.08
Output  | 0.00017945 | 0.00017945 | 0.00017945 |   0.0 |  0.00
Modify  | 0.70377    | 0.70377    | 0.70377    |   0.0 |  0.36
Other   |            | 0.1008     |            |       |  0.05

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

Total # of neighbors = 311954
Ave neighs/atom = 77.988500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.89445479268, Press = 0.0665427520100662
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   36000   -22759.403   -22759.403   -22918.423   -22918.423    307.63442    307.63442    60659.801    60659.801    829.41794    829.41794 
   37000   -22759.756   -22759.756   -22923.251   -22923.251    316.29321    316.29321    60685.376    60685.376   -993.95462   -993.95462 
Loop time of 198.234 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.065 hours/ns, 5.045 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.28     | 197.28     | 197.28     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14978    | 0.14978    | 0.14978    |   0.0 |  0.08
Output  | 0.00022886 | 0.00022886 | 0.00022886 |   0.0 |  0.00
Modify  | 0.70408    | 0.70408    | 0.70408    |   0.0 |  0.36
Other   |            | 0.09953    |            |       |  0.05

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

Total # of neighbors = 311956
Ave neighs/atom = 77.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.885011267671, Press = -0.0420105888195024
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   37000   -22759.756   -22759.756   -22923.251   -22923.251    316.29321    316.29321    60685.376    60685.376   -993.95462   -993.95462 
   38000   -22758.537   -22758.537   -22919.597   -22919.597    311.58128    311.58128    60705.457    60705.457   -1436.2698   -1436.2698 
Loop time of 205.309 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 57.030 hours/ns, 4.871 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    | 204.3      | 204.3      | 204.3      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15536    | 0.15536    | 0.15536    |   0.0 |  0.08
Output  | 0.00017345 | 0.00017345 | 0.00017345 |   0.0 |  0.00
Modify  | 0.74907    | 0.74907    | 0.74907    |   0.0 |  0.36
Other   |            | 0.1022     |            |       |  0.05

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

Total # of neighbors = 311960
Ave neighs/atom = 77.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 = 312.804043415556, Press = 0.276066660120238
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   38000   -22758.537   -22758.537   -22919.597   -22919.597    311.58128    311.58128    60705.457    60705.457   -1436.2698   -1436.2698 
   39000   -22752.619   -22752.619   -22914.947   -22914.947    314.03457    314.03457    60640.417    60640.417    2194.2514    2194.2514 
Loop time of 207.556 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.416 ns/day, 57.654 hours/ns, 4.818 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    | 206.54     | 206.54     | 206.54     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15704    | 0.15704    | 0.15704    |   0.0 |  0.08
Output  | 0.00017612 | 0.00017612 | 0.00017612 |   0.0 |  0.00
Modify  | 0.7536     | 0.7536     | 0.7536     |   0.0 |  0.36
Other   |            | 0.1032     |            |       |  0.05

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

Total # of neighbors = 311946
Ave neighs/atom = 77.986500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.852930632484, Press = 2.99542677896634
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   39000   -22752.619   -22752.619   -22914.947   -22914.947    314.03457    314.03457    60640.417    60640.417    2194.2514    2194.2514 
   40000   -22757.493   -22757.493   -22920.197   -22920.197    314.76258    314.76258    60651.995    60651.995    955.96309    955.96309 
Loop time of 201.687 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.024 hours/ns, 4.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    | 200.71     | 200.71     | 200.71     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15207    | 0.15207    | 0.15207    |   0.0 |  0.08
Output  | 0.00017566 | 0.00017566 | 0.00017566 |   0.0 |  0.00
Modify  | 0.72393    | 0.72393    | 0.72393    |   0.0 |  0.36
Other   |            | 0.1002     |            |       |  0.05

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

Total # of neighbors = 311952
Ave neighs/atom = 77.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.827501850808, Press = -0.182239069367952
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   40000   -22757.493   -22757.493   -22920.197   -22920.197    314.76258    314.76258    60651.995    60651.995    955.96309    955.96309 
   41000   -22758.153   -22758.153   -22917.349   -22917.349    307.97614    307.97614    60672.119    60672.119    429.94512    429.94512 
Loop time of 203.856 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.627 hours/ns, 4.905 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    | 202.86     | 202.86     | 202.86     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15396    | 0.15396    | 0.15396    |   0.0 |  0.08
Output  | 0.0025558  | 0.0025558  | 0.0025558  |   0.0 |  0.00
Modify  | 0.73505    | 0.73505    | 0.73505    |   0.0 |  0.36
Other   |            | 0.1007     |            |       |  0.05

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

Total # of neighbors = 311968
Ave neighs/atom = 77.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 = 312.827501268885, Press = 0.428214977579891
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   41000   -22758.153   -22758.153   -22917.349   -22917.349    307.97614    307.97614    60672.119    60672.119    429.94512    429.94512 
   42000   -22754.842   -22754.842   -22918.754   -22918.754    317.09777    317.09777    60708.467    60708.467   -1497.7213   -1497.7213 
Loop time of 199.532 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.425 hours/ns, 5.012 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    | 198.57     | 198.57     | 198.57     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14988    | 0.14988    | 0.14988    |   0.0 |  0.08
Output  | 0.00021562 | 0.00021562 | 0.00021562 |   0.0 |  0.00
Modify  | 0.70996    | 0.70996    | 0.70996    |   0.0 |  0.36
Other   |            | 0.1003     |            |       |  0.05

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

Total # of neighbors = 311970
Ave neighs/atom = 77.992500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.830727053604, Press = 0.498870574973091
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   42000   -22754.842   -22754.842   -22918.754   -22918.754    317.09777    317.09777    60708.467    60708.467   -1497.7213   -1497.7213 
   43000   -22755.992   -22755.992   -22917.217   -22917.217    311.90057    311.90057    60676.267    60676.267    231.40525    231.40525 
Loop time of 202.986 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.385 hours/ns, 4.926 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    | 202        | 202        | 202        |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15282    | 0.15282    | 0.15282    |   0.0 |  0.08
Output  | 0.00017474 | 0.00017474 | 0.00017474 |   0.0 |  0.00
Modify  | 0.73354    | 0.73354    | 0.73354    |   0.0 |  0.36
Other   |            | 0.1014     |            |       |  0.05

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

Total # of neighbors = 311980
Ave neighs/atom = 77.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 = 312.876240130562, Press = 1.74480695993232
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   43000   -22755.992   -22755.992   -22917.217   -22917.217    311.90057    311.90057    60676.267    60676.267    231.40525    231.40525 
   44000   -22757.314   -22757.314    -22917.52    -22917.52    309.93086    309.93086    60610.527    60610.527    3244.9552    3244.9552 
Loop time of 202.722 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.312 hours/ns, 4.933 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    | 201.73     | 201.73     | 201.73     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15262    | 0.15262    | 0.15262    |   0.0 |  0.08
Output  | 0.00017618 | 0.00017618 | 0.00017618 |   0.0 |  0.00
Modify  | 0.73793    | 0.73793    | 0.73793    |   0.0 |  0.36
Other   |            | 0.1015     |            |       |  0.05

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

Total # of neighbors = 311912
Ave neighs/atom = 77.978000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.868798640937, Press = 0.229888655287929
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   44000   -22757.314   -22757.314    -22917.52    -22917.52    309.93086    309.93086    60610.527    60610.527    3244.9552    3244.9552 
   45000   -22759.163   -22759.163   -22919.795   -22919.795    310.75268    310.75268    60683.647    60683.647    -444.0142    -444.0142 
Loop time of 202.73 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.426 ns/day, 56.314 hours/ns, 4.933 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    | 201.75     | 201.75     | 201.75     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15327    | 0.15327    | 0.15327    |   0.0 |  0.08
Output  | 0.00022041 | 0.00022041 | 0.00022041 |   0.0 |  0.00
Modify  | 0.72707    | 0.72707    | 0.72707    |   0.0 |  0.36
Other   |            | 0.1023     |            |       |  0.05

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

Total # of neighbors = 311968
Ave neighs/atom = 77.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 = 312.836237476828, Press = 0.335434095997736
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   45000   -22759.163   -22759.163   -22919.795   -22919.795    310.75268    310.75268    60683.647    60683.647    -444.0142    -444.0142 
   46000   -22760.399   -22760.399   -22921.754   -22921.754    312.15198    312.15198    60662.721    60662.721    307.80143    307.80143 
Loop time of 203.515 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.532 hours/ns, 4.914 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    | 202.53     | 202.53     | 202.53     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15393    | 0.15393    | 0.15393    |   0.0 |  0.08
Output  | 0.00017554 | 0.00017554 | 0.00017554 |   0.0 |  0.00
Modify  | 0.73204    | 0.73204    | 0.73204    |   0.0 |  0.36
Other   |            | 0.1024     |            |       |  0.05

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

Total # of neighbors = 311960
Ave neighs/atom = 77.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 = 312.834419534931, Press = 0.839849681440458
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   46000   -22760.399   -22760.399   -22921.754   -22921.754    312.15198    312.15198    60662.721    60662.721    307.80143    307.80143 
   47000    -22755.86    -22755.86   -22919.716   -22919.716    316.99143    316.99143    60689.153    60689.153   -669.58416   -669.58416 
Loop time of 201.698 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.027 hours/ns, 4.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    | 200.72     | 200.72     | 200.72     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15268    | 0.15268    | 0.15268    |   0.0 |  0.08
Output  | 0.00024825 | 0.00024825 | 0.00024825 |   0.0 |  0.00
Modify  | 0.72543    | 0.72543    | 0.72543    |   0.0 |  0.36
Other   |            | 0.1017     |            |       |  0.05

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

Total # of neighbors = 311958
Ave neighs/atom = 77.989500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.801302600567, Press = 0.957042159664142
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   47000    -22755.86    -22755.86   -22919.716   -22919.716    316.99143    316.99143    60689.153    60689.153   -669.58416   -669.58416 
   48000   -22762.209   -22762.209   -22921.572   -22921.572    308.29781    308.29781    60632.845    60632.845    1548.9188    1548.9188 
Loop time of 201.756 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.043 hours/ns, 4.956 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    | 200.78     | 200.78     | 200.78     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15208    | 0.15208    | 0.15208    |   0.0 |  0.08
Output  | 0.00022014 | 0.00022014 | 0.00022014 |   0.0 |  0.00
Modify  | 0.72376    | 0.72376    | 0.72376    |   0.0 |  0.36
Other   |            | 0.1006     |            |       |  0.05

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

Total # of neighbors = 311976
Ave neighs/atom = 77.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.775333065556, Press = -1.24810793428003
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   48000   -22762.209   -22762.209   -22921.572   -22921.572    308.29781    308.29781    60632.845    60632.845    1548.9188    1548.9188 
   49000   -22752.944   -22752.944   -22917.408   -22917.408    318.16576    318.16576    60714.462    60714.462   -1506.2585   -1506.2585 
Loop time of 205.217 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.421 ns/day, 57.005 hours/ns, 4.873 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    | 204.22     | 204.22     | 204.22     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15455    | 0.15455    | 0.15455    |   0.0 |  0.08
Output  | 0.00018463 | 0.00018463 | 0.00018463 |   0.0 |  0.00
Modify  | 0.74254    | 0.74254    | 0.74254    |   0.0 |  0.36
Other   |            | 0.1025     |            |       |  0.05

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

Total # of neighbors = 311958
Ave neighs/atom = 77.989500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.790749723394, Press = 1.6913388623729
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   49000   -22752.944   -22752.944   -22917.408   -22917.408    318.16576    318.16576    60714.462    60714.462   -1506.2585   -1506.2585 
   50000   -22757.053   -22757.053   -22920.705   -22920.705    316.59591    316.59591    60634.121    60634.121    1826.2734    1826.2734 
Loop time of 199.107 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.308 hours/ns, 5.022 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.14     | 198.14     | 198.14     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1512     | 0.1512     | 0.1512     |   0.0 |  0.08
Output  | 0.00017813 | 0.00017813 | 0.00017813 |   0.0 |  0.00
Modify  | 0.71288    | 0.71288    | 0.71288    |   0.0 |  0.36
Other   |            | 0.101      |            |       |  0.05

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

Total # of neighbors = 311954
Ave neighs/atom = 77.988500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.800618493501, Press = -0.0584844694347753
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   50000   -22757.053   -22757.053   -22920.705   -22920.705    316.59591    316.59591    60634.121    60634.121    1826.2734    1826.2734 
   51000   -22765.032   -22765.032   -22925.061   -22925.061    309.58683    309.58683    60682.083    60682.083   -1143.9846   -1143.9846 
Loop time of 200.737 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.760 hours/ns, 4.982 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    | 199.76     | 199.76     | 199.76     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15261    | 0.15261    | 0.15261    |   0.0 |  0.08
Output  | 0.00017563 | 0.00017563 | 0.00017563 |   0.0 |  0.00
Modify  | 0.72148    | 0.72148    | 0.72148    |   0.0 |  0.36
Other   |            | 0.1011     |            |       |  0.05

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

Total # of neighbors = 311974
Ave neighs/atom = 77.993500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.816780781835, Press = 0.327796641461644
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   51000   -22765.032   -22765.032   -22925.061   -22925.061    309.58683    309.58683    60682.083    60682.083   -1143.9846   -1143.9846 
   52000   -22756.961   -22756.961   -22918.837   -22918.837    313.16016    313.16016    60658.931    60658.931    931.54014    931.54014 
Loop time of 198.433 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.120 hours/ns, 5.039 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.46     | 197.46     | 197.46     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15181    | 0.15181    | 0.15181    |   0.0 |  0.08
Output  | 0.00017815 | 0.00017815 | 0.00017815 |   0.0 |  0.00
Modify  | 0.71758    | 0.71758    | 0.71758    |   0.0 |  0.36
Other   |            | 0.1014     |            |       |  0.05

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

Total # of neighbors = 311960
Ave neighs/atom = 77.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 = 312.801331410353, Press = 0.515992483019203
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   52000   -22756.961   -22756.961   -22918.837   -22918.837    313.16016    313.16016    60658.931    60658.931    931.54014    931.54014 
   53000   -22754.157   -22754.157   -22917.475   -22917.475    315.94973    315.94973    60685.218    60685.218   -151.70103   -151.70103 
Loop time of 201.25 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.903 hours/ns, 4.969 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    | 200.28     | 200.28     | 200.28     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15103    | 0.15103    | 0.15103    |   0.0 |  0.08
Output  | 0.00018162 | 0.00018162 | 0.00018162 |   0.0 |  0.00
Modify  | 0.72196    | 0.72196    | 0.72196    |   0.0 |  0.36
Other   |            | 0.1005     |            |       |  0.05

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

Total # of neighbors = 311962
Ave neighs/atom = 77.990500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.827868891719, Press = 0.477860513233009
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   53000   -22754.157   -22754.157   -22917.475   -22917.475    315.94973    315.94973    60685.218    60685.218   -151.70103   -151.70103 
   54000   -22760.457   -22760.457   -22920.466   -22920.466    309.54805    309.54805    60697.334    60697.334   -1115.4205   -1115.4205 
Loop time of 199.138 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.316 hours/ns, 5.022 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.18     | 198.18     | 198.18     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15085    | 0.15085    | 0.15085    |   0.0 |  0.08
Output  | 0.00017824 | 0.00017824 | 0.00017824 |   0.0 |  0.00
Modify  | 0.71193    | 0.71193    | 0.71193    |   0.0 |  0.36
Other   |            | 0.09998    |            |       |  0.05

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

Total # of neighbors = 311946
Ave neighs/atom = 77.986500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.860417402004, Press = 1.54527954913158
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   54000   -22760.457   -22760.457   -22920.466   -22920.466    309.54805    309.54805    60697.334    60697.334   -1115.4205   -1115.4205 
   55000   -22762.383   -22762.383    -22915.98    -22915.98    297.14429    297.14429    60618.261    60618.261    2995.8624    2995.8624 
Loop time of 198.51 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.142 hours/ns, 5.038 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.55     | 197.55     | 197.55     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14947    | 0.14947    | 0.14947    |   0.0 |  0.08
Output  | 0.00017603 | 0.00017603 | 0.00017603 |   0.0 |  0.00
Modify  | 0.7074     | 0.7074     | 0.7074     |   0.0 |  0.36
Other   |            | 0.09977    |            |       |  0.05

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

Total # of neighbors = 311952
Ave neighs/atom = 77.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.866362582045, Press = 0.843673791946247
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   55000   -22762.383   -22762.383    -22915.98    -22915.98    297.14429    297.14429    60618.261    60618.261    2995.8624    2995.8624 
   56000   -22758.993   -22758.993   -22919.273   -22919.273    310.07345    310.07345     60699.67     60699.67   -1152.4645   -1152.4645 
Loop time of 200.039 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.566 hours/ns, 4.999 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.07     | 199.07     | 199.07     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15018    | 0.15018    | 0.15018    |   0.0 |  0.08
Output  | 0.00017615 | 0.00017615 | 0.00017615 |   0.0 |  0.00
Modify  | 0.71634    | 0.71634    | 0.71634    |   0.0 |  0.36
Other   |            | 0.1006     |            |       |  0.05

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

Total # of neighbors = 311954
Ave neighs/atom = 77.988500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.876671312681, Press = 0.212976613445479
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   56000   -22758.993   -22758.993   -22919.273   -22919.273    310.07345    310.07345     60699.67     60699.67   -1152.4645   -1152.4645 
   57000   -22756.491   -22756.491   -22917.183   -22917.183    310.86827    310.86827    60646.604    60646.604    1576.2846    1576.2846 
Loop time of 198.556 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.154 hours/ns, 5.036 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    | 197.59     | 197.59     | 197.59     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15166    | 0.15166    | 0.15166    |   0.0 |  0.08
Output  | 0.00024728 | 0.00024728 | 0.00024728 |   0.0 |  0.00
Modify  | 0.71252    | 0.71252    | 0.71252    |   0.0 |  0.36
Other   |            | 0.1004     |            |       |  0.05

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

Total # of neighbors = 311964
Ave neighs/atom = 77.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.846697401171, Press = 0.520510532991749
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   57000   -22756.491   -22756.491   -22917.183   -22917.183    310.86827    310.86827    60646.604    60646.604    1576.2846    1576.2846 
   58000    -22760.61    -22760.61   -22922.961   -22922.961    314.07959    314.07959    60651.297    60651.297    701.58467    701.58467 
Loop time of 197.984 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 54.996 hours/ns, 5.051 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.02     | 197.02     | 197.02     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15125    | 0.15125    | 0.15125    |   0.0 |  0.08
Output  | 0.00017807 | 0.00017807 | 0.00017807 |   0.0 |  0.00
Modify  | 0.71348    | 0.71348    | 0.71348    |   0.0 |  0.36
Other   |            | 0.1012     |            |       |  0.05

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

Total # of neighbors = 311946
Ave neighs/atom = 77.986500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.837358449523, Press = 0.432475456293179
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   58000    -22760.61    -22760.61   -22922.961   -22922.961    314.07959    314.07959    60651.297    60651.297    701.58467    701.58467 
   59000   -22755.978   -22755.978   -22918.773   -22918.773    314.93876    314.93876    60732.226    60732.226   -2539.2863   -2539.2863 
Loop time of 198.467 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.130 hours/ns, 5.039 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.51     | 197.51     | 197.51     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14929    | 0.14929    | 0.14929    |   0.0 |  0.08
Output  | 0.00017648 | 0.00017648 | 0.00017648 |   0.0 |  0.00
Modify  | 0.70625    | 0.70625    | 0.70625    |   0.0 |  0.36
Other   |            | 0.1009     |            |       |  0.05

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

Total # of neighbors = 311976
Ave neighs/atom = 77.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.82398167793, Press = 0.676456314864946
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   59000   -22755.978   -22755.978   -22918.773   -22918.773    314.93876    314.93876    60732.226    60732.226   -2539.2863   -2539.2863 
   60000   -22752.627   -22752.627   -22919.785   -22919.785    323.37861    323.37861    60664.869    60664.869    529.59866    529.59866 
Loop time of 199.303 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.362 hours/ns, 5.017 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    | 198.34     | 198.34     | 198.34     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14882    | 0.14882    | 0.14882    |   0.0 |  0.07
Output  | 0.00017457 | 0.00017457 | 0.00017457 |   0.0 |  0.00
Modify  | 0.70921    | 0.70921    | 0.70921    |   0.0 |  0.36
Other   |            | 0.1014     |            |       |  0.05

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

Total # of neighbors = 311970
Ave neighs/atom = 77.992500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.837662776405, Press = 1.4883967135567
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   60000   -22752.627   -22752.627   -22919.785   -22919.785    323.37861    323.37861    60664.869    60664.869    529.59866    529.59866 
   61000   -22757.942   -22757.942   -22920.896   -22920.896    315.24496    315.24496    60649.625    60649.625    938.44919    938.44919 
Loop time of 202.198 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.427 ns/day, 56.166 hours/ns, 4.946 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    | 201.21     | 201.21     | 201.21     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15296    | 0.15296    | 0.15296    |   0.0 |  0.08
Output  | 0.00017553 | 0.00017553 | 0.00017553 |   0.0 |  0.00
Modify  | 0.73026    | 0.73026    | 0.73026    |   0.0 |  0.36
Other   |            | 0.102      |            |       |  0.05

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

Total # of neighbors = 311974
Ave neighs/atom = 77.993500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.878498226654, Press = -0.50604246407351
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   61000   -22757.942   -22757.942   -22920.896   -22920.896    315.24496    315.24496    60649.625    60649.625    938.44919    938.44919 
   62000   -22753.507   -22753.507     -22914.3     -22914.3    311.06562    311.06562    60716.387    60716.387    -1328.159    -1328.159 
Loop time of 196.461 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.572 hours/ns, 5.090 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    | 195.51     | 195.51     | 195.51     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14912    | 0.14912    | 0.14912    |   0.0 |  0.08
Output  | 0.00018681 | 0.00018681 | 0.00018681 |   0.0 |  0.00
Modify  | 0.69969    | 0.69969    | 0.69969    |   0.0 |  0.36
Other   |            | 0.09998    |            |       |  0.05

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

Total # of neighbors = 311964
Ave neighs/atom = 77.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.902949560558, Press = 1.40695979019181
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   62000   -22753.507   -22753.507     -22914.3     -22914.3    311.06562    311.06562    60716.387    60716.387    -1328.159    -1328.159 
   63000   -22756.913   -22756.913   -22919.731   -22919.731    314.98322    314.98322    60673.399    60673.399   -7.5335642   -7.5335642 
Loop time of 195.711 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.364 hours/ns, 5.110 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    | 194.77     | 194.77     | 194.77     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14739    | 0.14739    | 0.14739    |   0.0 |  0.08
Output  | 0.00017357 | 0.00017357 | 0.00017357 |   0.0 |  0.00
Modify  | 0.69586    | 0.69586    | 0.69586    |   0.0 |  0.36
Other   |            | 0.0993     |            |       |  0.05

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

Total # of neighbors = 311924
Ave neighs/atom = 77.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 = 312.933728663646, Press = -0.00203901410018192
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   63000   -22756.913   -22756.913   -22919.731   -22919.731    314.98322    314.98322    60673.399    60673.399   -7.5335642   -7.5335642 
   64000   -22756.363   -22756.363   -22919.163   -22919.163    314.94822    314.94822    60680.847    60680.847   -270.91301   -270.91301 
Loop time of 200.439 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.678 hours/ns, 4.989 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    | 199.47     | 199.47     | 199.47     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.152      | 0.152      | 0.152      |   0.0 |  0.08
Output  | 0.00017761 | 0.00017761 | 0.00017761 |   0.0 |  0.00
Modify  | 0.71997    | 0.71997    | 0.71997    |   0.0 |  0.36
Other   |            | 0.1007     |            |       |  0.05

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

Total # of neighbors = 311924
Ave neighs/atom = 77.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 = 312.908633968995, Press = 0.580812105469142
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   64000   -22756.363   -22756.363   -22919.163   -22919.163    314.94822    314.94822    60680.847    60680.847   -270.91301   -270.91301 
   65000   -22764.721   -22764.721   -22922.177   -22922.177    304.60964    304.60964    60664.076    60664.076    10.006216    10.006216 
Loop time of 201.228 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.897 hours/ns, 4.969 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    | 200.25     | 200.25     | 200.25     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15202    | 0.15202    | 0.15202    |   0.0 |  0.08
Output  | 0.00022575 | 0.00022575 | 0.00022575 |   0.0 |  0.00
Modify  | 0.72831    | 0.72831    | 0.72831    |   0.0 |  0.36
Other   |            | 0.1022     |            |       |  0.05

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

Total # of neighbors = 311956
Ave neighs/atom = 77.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.887741262943, Press = 0.249514516182941
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   65000   -22764.721   -22764.721   -22922.177   -22922.177    304.60964    304.60964    60664.076    60664.076    10.006216    10.006216 
   66000    -22753.35    -22753.35   -22918.208   -22918.208    318.92826    318.92826    60718.288    60718.288   -1887.5858   -1887.5858 
Loop time of 198.059 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.017 hours/ns, 5.049 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    | 197.1      | 197.1      | 197.1      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15029    | 0.15029    | 0.15029    |   0.0 |  0.08
Output  | 0.00021666 | 0.00021666 | 0.00021666 |   0.0 |  0.00
Modify  | 0.7075     | 0.7075     | 0.7075     |   0.0 |  0.36
Other   |            | 0.09943    |            |       |  0.05

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

Total # of neighbors = 311972
Ave neighs/atom = 77.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 = 312.878412089721, Press = 0.539252120761943
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   66000    -22753.35    -22753.35   -22918.208   -22918.208    318.92826    318.92826    60718.288    60718.288   -1887.5858   -1887.5858 
   67000   -22757.293   -22757.293   -22921.156   -22921.156     317.0029     317.0029    60639.977    60639.977    1338.3012    1338.3012 
Loop time of 199.319 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.367 hours/ns, 5.017 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    | 198.36     | 198.36     | 198.36     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14997    | 0.14997    | 0.14997    |   0.0 |  0.08
Output  | 0.00051874 | 0.00051874 | 0.00051874 |   0.0 |  0.00
Modify  | 0.70724    | 0.70724    | 0.70724    |   0.0 |  0.35
Other   |            | 0.1004     |            |       |  0.05

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

Total # of neighbors = 311958
Ave neighs/atom = 77.989500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.873817187483, Press = 1.09105574186653
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   67000   -22757.293   -22757.293   -22921.156   -22921.156     317.0029     317.0029    60639.977    60639.977    1338.3012    1338.3012 
   68000    -22756.34    -22756.34   -22918.828   -22918.828    314.34297    314.34297    60706.676    60706.676   -1472.9607   -1472.9607 
Loop time of 198.979 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.272 hours/ns, 5.026 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.02     | 198.02     | 198.02     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15106    | 0.15106    | 0.15106    |   0.0 |  0.08
Output  | 0.00023529 | 0.00023529 | 0.00023529 |   0.0 |  0.00
Modify  | 0.71031    | 0.71031    | 0.71031    |   0.0 |  0.36
Other   |            | 0.1011     |            |       |  0.05

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

Total # of neighbors = 311942
Ave neighs/atom = 77.985500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.893045520191, Press = -0.0965555437434973
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   68000    -22756.34    -22756.34   -22918.828   -22918.828    314.34297    314.34297    60706.676    60706.676   -1472.9607   -1472.9607 
   69000   -22755.565   -22755.565   -22920.509   -22920.509    319.09536    319.09536     60670.99     60670.99    82.808818    82.808818 
Loop time of 199.798 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.499 hours/ns, 5.005 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    | 198.83     | 198.83     | 198.83     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15016    | 0.15016    | 0.15016    |   0.0 |  0.08
Output  | 0.00028053 | 0.00028053 | 0.00028053 |   0.0 |  0.00
Modify  | 0.71487    | 0.71487    | 0.71487    |   0.0 |  0.36
Other   |            | 0.1002     |            |       |  0.05

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

Total # of neighbors = 311942
Ave neighs/atom = 77.985500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.892525448771, Press = 0.466372087010929
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   69000   -22755.565   -22755.565   -22920.509   -22920.509    319.09536    319.09536     60670.99     60670.99    82.808818    82.808818 
   70000   -22757.124   -22757.124   -22919.682   -22919.682    314.47897    314.47897    60689.706    60689.706   -754.07046   -754.07046 
Loop time of 198.135 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.037 hours/ns, 5.047 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    | 197.18     | 197.18     | 197.18     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14949    | 0.14949    | 0.14949    |   0.0 |  0.08
Output  | 0.00017751 | 0.00017751 | 0.00017751 |   0.0 |  0.00
Modify  | 0.7041     | 0.7041     | 0.7041     |   0.0 |  0.36
Other   |            | 0.1006     |            |       |  0.05

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

Total # of neighbors = 311968
Ave neighs/atom = 77.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 = 312.929954082783, Press = -0.212669067185861
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   70000   -22757.124   -22757.124   -22919.682   -22919.682    314.47897    314.47897    60689.706    60689.706   -754.07046   -754.07046 
   71000   -22754.542   -22754.542    -22918.16    -22918.16    316.52979    316.52979    60658.618    60658.618    960.33429    960.33429 
Loop time of 195.968 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.436 hours/ns, 5.103 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    | 195.02     | 195.02     | 195.02     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14762    | 0.14762    | 0.14762    |   0.0 |  0.08
Output  | 0.00018124 | 0.00018124 | 0.00018124 |   0.0 |  0.00
Modify  | 0.70089    | 0.70089    | 0.70089    |   0.0 |  0.36
Other   |            | 0.1004     |            |       |  0.05

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

Total # of neighbors = 311958
Ave neighs/atom = 77.989500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.931640391079, Press = 0.762289760782708
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   71000   -22754.542   -22754.542    -22918.16    -22918.16    316.52979    316.52979    60658.618    60658.618    960.33429    960.33429 
   72000   -22755.334   -22755.334   -22916.564   -22916.564    311.90978    311.90978    60692.466    60692.466   -439.85235   -439.85235 
Loop time of 196.071 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.464 hours/ns, 5.100 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    | 195.12     | 195.12     | 195.12     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14797    | 0.14797    | 0.14797    |   0.0 |  0.08
Output  | 0.00018178 | 0.00018178 | 0.00018178 |   0.0 |  0.00
Modify  | 0.69964    | 0.69964    | 0.69964    |   0.0 |  0.36
Other   |            | 0.1011     |            |       |  0.05

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

Total # of neighbors = 311956
Ave neighs/atom = 77.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.946554412782, Press = 0.413130437917678
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   72000   -22755.334   -22755.334   -22916.564   -22916.564    311.90978    311.90978    60692.466    60692.466   -439.85235   -439.85235 
   73000   -22759.344   -22759.344   -22918.259   -22918.259    307.43257    307.43257    60652.421    60652.421    1185.2449    1185.2449 
Loop time of 196.335 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.537 hours/ns, 5.093 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    | 195.39     | 195.39     | 195.39     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14885    | 0.14885    | 0.14885    |   0.0 |  0.08
Output  | 0.00017463 | 0.00017463 | 0.00017463 |   0.0 |  0.00
Modify  | 0.6981     | 0.6981     | 0.6981     |   0.0 |  0.36
Other   |            | 0.1014     |            |       |  0.05

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

Total # of neighbors = 311942
Ave neighs/atom = 77.985500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.948035487861, Press = 0.657076570298602
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   73000   -22759.344   -22759.344   -22918.259   -22918.259    307.43257    307.43257    60652.421    60652.421    1185.2449    1185.2449 
   74000   -22756.112   -22756.112    -22915.96    -22915.96    309.23664    309.23664    60674.287    60674.287    361.33335    361.33335 
Loop time of 193.778 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.446 ns/day, 53.827 hours/ns, 5.161 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    | 192.85     | 192.85     | 192.85     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14748    | 0.14748    | 0.14748    |   0.0 |  0.08
Output  | 0.0001779  | 0.0001779  | 0.0001779  |   0.0 |  0.00
Modify  | 0.68601    | 0.68601    | 0.68601    |   0.0 |  0.35
Other   |            | 0.09878    |            |       |  0.05

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

Total # of neighbors = 311954
Ave neighs/atom = 77.988500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.93239281281, Press = -0.239674931720827
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   74000   -22756.112   -22756.112    -22915.96    -22915.96    309.23664    309.23664    60674.287    60674.287    361.33335    361.33335 
   75000   -22764.272   -22764.272    -22921.41    -22921.41    303.99472    303.99472    60682.402    60682.402   -791.01247   -791.01247 
Loop time of 193.101 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.447 ns/day, 53.639 hours/ns, 5.179 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    | 192.17     | 192.17     | 192.17     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14705    | 0.14705    | 0.14705    |   0.0 |  0.08
Output  | 0.00017601 | 0.00017601 | 0.00017601 |   0.0 |  0.00
Modify  | 0.6865     | 0.6865     | 0.6865     |   0.0 |  0.36
Other   |            | 0.09858    |            |       |  0.05

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

Total # of neighbors = 311960
Ave neighs/atom = 77.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 = 312.925087158748, Press = 0.622803761542659
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   75000   -22764.272   -22764.272    -22921.41    -22921.41    303.99472    303.99472    60682.402    60682.402   -791.01247   -791.01247 
   76000   -22756.416   -22756.416   -22918.305   -22918.305    313.18641    313.18641    60632.565    60632.565    2045.6133    2045.6133 
Loop time of 192.65 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.448 ns/day, 53.514 hours/ns, 5.191 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    | 191.72     | 191.72     | 191.72     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14696    | 0.14696    | 0.14696    |   0.0 |  0.08
Output  | 0.00017833 | 0.00017833 | 0.00017833 |   0.0 |  0.00
Modify  | 0.68536    | 0.68536    | 0.68536    |   0.0 |  0.36
Other   |            | 0.1005     |            |       |  0.05

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

Total # of neighbors = 311940
Ave neighs/atom = 77.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 = 312.895989816782, Press = 0.811315121398238
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   76000   -22756.416   -22756.416   -22918.305   -22918.305    313.18641    313.18641    60632.565    60632.565    2045.6133    2045.6133 
   77000    -22760.37    -22760.37   -22920.954   -22920.954    310.66149    310.66149    60700.137    60700.137   -1414.2501   -1414.2501 
Loop time of 196.476 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.577 hours/ns, 5.090 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    | 195.52     | 195.52     | 195.52     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15166    | 0.15166    | 0.15166    |   0.0 |  0.08
Output  | 0.00018008 | 0.00018008 | 0.00018008 |   0.0 |  0.00
Modify  | 0.70513    | 0.70513    | 0.70513    |   0.0 |  0.36
Other   |            | 0.1002     |            |       |  0.05

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

Total # of neighbors = 311956
Ave neighs/atom = 77.989000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.894411542991, Press = -0.0188083645348937
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   77000    -22760.37    -22760.37   -22920.954   -22920.954    310.66149    310.66149    60700.137    60700.137   -1414.2501   -1414.2501 
   78000   -22755.598   -22755.598   -22918.817   -22918.817    315.75813    315.75813    60675.282    60675.282   -20.376372   -20.376372 
Loop time of 194.049 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.445 ns/day, 53.902 hours/ns, 5.153 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    | 193.11     | 193.11     | 193.11     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14829    | 0.14829    | 0.14829    |   0.0 |  0.08
Output  | 0.00017454 | 0.00017454 | 0.00017454 |   0.0 |  0.00
Modify  | 0.69013    | 0.69013    | 0.69013    |   0.0 |  0.36
Other   |            | 0.09925    |            |       |  0.05

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

Total # of neighbors = 311962
Ave neighs/atom = 77.990500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.8781226351, Press = 0.979886438697015
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   78000   -22755.598   -22755.598   -22918.817   -22918.817    315.75813    315.75813    60675.282    60675.282   -20.376372   -20.376372 
   79000   -22760.785   -22760.785   -22920.625   -22920.625     309.2212     309.2212    60646.549    60646.549    1109.7701    1109.7701 
Loop time of 195.079 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.188 hours/ns, 5.126 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    | 194.13     | 194.13     | 194.13     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1485     | 0.1485     | 0.1485     |   0.0 |  0.08
Output  | 0.00017449 | 0.00017449 | 0.00017449 |   0.0 |  0.00
Modify  | 0.69788    | 0.69788    | 0.69788    |   0.0 |  0.36
Other   |            | 0.1006     |            |       |  0.05

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

Total # of neighbors = 311944
Ave neighs/atom = 77.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 = 312.872622215027, Press = 0.542866688335584
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   79000   -22760.785   -22760.785   -22920.625   -22920.625     309.2212     309.2212    60646.549    60646.549    1109.7701    1109.7701 
   80000   -22754.922   -22754.922   -22916.495   -22916.495    312.57437    312.57437     60657.83     60657.83     1078.586     1078.586 
Loop time of 198.608 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.169 hours/ns, 5.035 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.64     | 197.64     | 197.64     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15121    | 0.15121    | 0.15121    |   0.0 |  0.08
Output  | 0.0001799  | 0.0001799  | 0.0001799  |   0.0 |  0.00
Modify  | 0.71374    | 0.71374    | 0.71374    |   0.0 |  0.36
Other   |            | 0.101      |            |       |  0.05

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

Total # of neighbors = 311972
Ave neighs/atom = 77.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 = 312.885844134286, Press = 0.263287691913779
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   80000   -22754.922   -22754.922   -22916.495   -22916.495    312.57437    312.57437     60657.83     60657.83     1078.586     1078.586 
   81000   -22756.456   -22756.456   -22916.355   -22916.355    309.33528    309.33528    60711.201    60711.201   -1402.7663   -1402.7663 
Loop time of 195.12 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.200 hours/ns, 5.125 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    | 194.18     | 194.18     | 194.18     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1495     | 0.1495     | 0.1495     |   0.0 |  0.08
Output  | 0.0001764  | 0.0001764  | 0.0001764  |   0.0 |  0.00
Modify  | 0.69344    | 0.69344    | 0.69344    |   0.0 |  0.36
Other   |            | 0.1002     |            |       |  0.05

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

Total # of neighbors = 311952
Ave neighs/atom = 77.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.884687834871, Press = -0.176702516260214
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   81000   -22756.456   -22756.456   -22916.355   -22916.355    309.33528    309.33528    60711.201    60711.201   -1402.7663   -1402.7663 
   82000    -22762.95    -22762.95   -22920.853   -22920.853    305.47576    305.47576    60648.921    60648.921    791.70315    791.70315 
Loop time of 197.837 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.955 hours/ns, 5.055 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    | 196.87     | 196.87     | 196.87     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15219    | 0.15219    | 0.15219    |   0.0 |  0.08
Output  | 0.00017664 | 0.00017664 | 0.00017664 |   0.0 |  0.00
Modify  | 0.70935    | 0.70935    | 0.70935    |   0.0 |  0.36
Other   |            | 0.1012     |            |       |  0.05

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

Total # of neighbors = 311950
Ave neighs/atom = 77.987500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.873963457502, Press = 0.906126775812983
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   82000    -22762.95    -22762.95   -22920.853   -22920.853    305.47576    305.47576    60648.921    60648.921    791.70315    791.70315 
   83000   -22756.066   -22756.066    -22918.82    -22918.82    314.85878    314.85878     60682.18     60682.18   -249.58437   -249.58437 
Loop time of 196.221 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.506 hours/ns, 5.096 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    | 195.26     | 195.26     | 195.26     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1499     | 0.1499     | 0.1499     |   0.0 |  0.08
Output  | 0.0001763  | 0.0001763  | 0.0001763  |   0.0 |  0.00
Modify  | 0.70644    | 0.70644    | 0.70644    |   0.0 |  0.36
Other   |            | 0.1013     |            |       |  0.05

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

Total # of neighbors = 311964
Ave neighs/atom = 77.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.862034892746, Press = 0.0894898093903114
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   83000   -22756.066   -22756.066    -22918.82    -22918.82    314.85878    314.85878     60682.18     60682.18   -249.58437   -249.58437 
   84000   -22756.242   -22756.242   -22917.521   -22917.521    312.00439    312.00439    60678.663    60678.663   -18.530431   -18.530431 
Loop time of 194.092 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.445 ns/day, 53.914 hours/ns, 5.152 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    | 193.15     | 193.15     | 193.15     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14503    | 0.14503    | 0.14503    |   0.0 |  0.07
Output  | 0.00017852 | 0.00017852 | 0.00017852 |   0.0 |  0.00
Modify  | 0.69207    | 0.69207    | 0.69207    |   0.0 |  0.36
Other   |            | 0.09991    |            |       |  0.05

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

Total # of neighbors = 311942
Ave neighs/atom = 77.985500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.845475691303, Press = 0.916716912460903
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   84000   -22756.242   -22756.242   -22917.521   -22917.521    312.00439    312.00439    60678.663    60678.663   -18.530431   -18.530431 
   85000   -22758.579   -22758.579   -22919.852   -22919.852    311.99385    311.99385    60656.165    60656.165    800.54469    800.54469 
Loop time of 194.122 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.445 ns/day, 53.923 hours/ns, 5.151 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    | 193.19     | 193.19     | 193.19     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14562    | 0.14562    | 0.14562    |   0.0 |  0.08
Output  | 0.00017437 | 0.00017437 | 0.00017437 |   0.0 |  0.00
Modify  | 0.6893     | 0.6893     | 0.6893     |   0.0 |  0.36
Other   |            | 0.09974    |            |       |  0.05

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

Total # of neighbors = 311942
Ave neighs/atom = 77.985500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.849290129896, Press = 0.172139535290345
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   85000   -22758.579   -22758.579   -22919.852   -22919.852    311.99385    311.99385    60656.165    60656.165    800.54469    800.54469 
   86000   -22755.229   -22755.229   -22918.314   -22918.314     315.4985     315.4985    60755.815    60755.815   -3566.6913   -3566.6913 
Loop time of 198.34 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.094 hours/ns, 5.042 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    | 197.38     | 197.38     | 197.38     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14881    | 0.14881    | 0.14881    |   0.0 |  0.08
Output  | 0.00017658 | 0.00017658 | 0.00017658 |   0.0 |  0.00
Modify  | 0.71381    | 0.71381    | 0.71381    |   0.0 |  0.36
Other   |            | 0.1015     |            |       |  0.05

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

Total # of neighbors = 311968
Ave neighs/atom = 77.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 = 312.869724857504, Press = -0.0793379819628906
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   86000   -22755.229   -22755.229   -22918.314   -22918.314     315.4985     315.4985    60755.815    60755.815   -3566.6913   -3566.6913 
   87000   -22761.591   -22761.591   -22920.949   -22920.949    308.28951    308.28951    60648.406    60648.406    1000.8151    1000.8151 
Loop time of 200.171 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.603 hours/ns, 4.996 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    | 199.2      | 199.2      | 199.2      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14941    | 0.14941    | 0.14941    |   0.0 |  0.07
Output  | 0.000221   | 0.000221   | 0.000221   |   0.0 |  0.00
Modify  | 0.71597    | 0.71597    | 0.71597    |   0.0 |  0.36
Other   |            | 0.1015     |            |       |  0.05

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

Total # of neighbors = 311954
Ave neighs/atom = 77.988500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.872604749122, Press = 0.672902595979825
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   87000   -22761.591   -22761.591   -22920.949   -22920.949    308.28951    308.28951    60648.406    60648.406    1000.8151    1000.8151 
   88000   -22754.322   -22754.322   -22916.427   -22916.427    313.60321    313.60321    60664.628    60664.628    995.42938    995.42938 
Loop time of 198.858 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.434 ns/day, 55.238 hours/ns, 5.029 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.89     | 197.89     | 197.89     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15016    | 0.15016    | 0.15016    |   0.0 |  0.08
Output  | 0.00017788 | 0.00017788 | 0.00017788 |   0.0 |  0.00
Modify  | 0.71347    | 0.71347    | 0.71347    |   0.0 |  0.36
Other   |            | 0.1021     |            |       |  0.05

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

Total # of neighbors = 311976
Ave neighs/atom = 77.994000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.869049636075, Press = 0.334305479208418
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   88000   -22754.322   -22754.322   -22916.427   -22916.427    313.60321    313.60321    60664.628    60664.628    995.42938    995.42938 
   89000   -22758.007   -22758.007   -22920.421   -22920.421    314.20167    314.20167    60643.525    60643.525    1439.9272    1439.9272 
Loop time of 195.986 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.441 hours/ns, 5.102 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    | 195.04     | 195.04     | 195.04     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14711    | 0.14711    | 0.14711    |   0.0 |  0.08
Output  | 0.00021934 | 0.00021934 | 0.00021934 |   0.0 |  0.00
Modify  | 0.69964    | 0.69964    | 0.69964    |   0.0 |  0.36
Other   |            | 0.1009     |            |       |  0.05

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

Total # of neighbors = 311946
Ave neighs/atom = 77.986500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.861162177789, Press = 0.33054847930839
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   89000   -22758.007   -22758.007   -22920.421   -22920.421    314.20167    314.20167    60643.525    60643.525    1439.9272    1439.9272 
   90000   -22753.755   -22753.755   -22914.468   -22914.468    310.90959    310.90959    60705.253    60705.253    -710.7593    -710.7593 
Loop time of 200.486 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.691 hours/ns, 4.988 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 199.52     | 199.52     | 199.52     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14848    | 0.14848    | 0.14848    |   0.0 |  0.07
Output  | 0.00024973 | 0.00024973 | 0.00024973 |   0.0 |  0.00
Modify  | 0.71754    | 0.71754    | 0.71754    |   0.0 |  0.36
Other   |            | 0.1009     |            |       |  0.05

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

Total # of neighbors = 311962
Ave neighs/atom = 77.990500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.862379812135, Press = 0.0163737174256148
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   90000   -22753.755   -22753.755   -22914.468   -22914.468    310.90959    310.90959    60705.253    60705.253    -710.7593    -710.7593 
   91000    -22758.92    -22758.92   -22919.431   -22919.431    310.51876    310.51876     60705.81     60705.81   -1486.3131   -1486.3131 
Loop time of 199.524 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.423 hours/ns, 5.012 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.56     | 198.56     | 198.56     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14923    | 0.14923    | 0.14923    |   0.0 |  0.07
Output  | 0.0001734  | 0.0001734  | 0.0001734  |   0.0 |  0.00
Modify  | 0.71148    | 0.71148    | 0.71148    |   0.0 |  0.36
Other   |            | 0.1013     |            |       |  0.05

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

Total # of neighbors = 311942
Ave neighs/atom = 77.985500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.885797122004, Press = 0.252215272931985
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   91000    -22758.92    -22758.92   -22919.431   -22919.431    310.51876    310.51876     60705.81     60705.81   -1486.3131   -1486.3131 
   92000   -22755.579   -22755.579   -22917.178   -22917.178    312.62369    312.62369    60658.238    60658.238    1048.1931    1048.1931 
Loop time of 199.925 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.535 hours/ns, 5.002 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 198.96     | 198.96     | 198.96     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14995    | 0.14995    | 0.14995    |   0.0 |  0.08
Output  | 0.00017814 | 0.00017814 | 0.00017814 |   0.0 |  0.00
Modify  | 0.71455    | 0.71455    | 0.71455    |   0.0 |  0.36
Other   |            | 0.1009     |            |       |  0.05

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

Total # of neighbors = 311958
Ave neighs/atom = 77.989500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.906175101575, Press = 0.412587067851747
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   92000   -22755.579   -22755.579   -22917.178   -22917.178    312.62369    312.62369    60658.238    60658.238    1048.1931    1048.1931 
   93000   -22759.651   -22759.651   -22920.439   -22920.439    311.05507    311.05507    60663.002    60663.002    469.46889    469.46889 
Loop time of 198.544 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.151 hours/ns, 5.037 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    | 197.58     | 197.58     | 197.58     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14883    | 0.14883    | 0.14883    |   0.0 |  0.07
Output  | 0.00051412 | 0.00051412 | 0.00051412 |   0.0 |  0.00
Modify  | 0.71856    | 0.71856    | 0.71856    |   0.0 |  0.36
Other   |            | 0.0999     |            |       |  0.05

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

Total # of neighbors = 311940
Ave neighs/atom = 77.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 = 312.88889656791, Press = 0.914775954596517
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   93000   -22759.651   -22759.651   -22920.439   -22920.439    311.05507    311.05507    60663.002    60663.002    469.46889    469.46889 
   94000   -22758.963   -22758.963   -22918.906   -22918.906    309.42125    309.42125    60644.949    60644.949     1378.974     1378.974 
Loop time of 194.799 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.444 ns/day, 54.111 hours/ns, 5.133 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    | 193.86     | 193.86     | 193.86     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14708    | 0.14708    | 0.14708    |   0.0 |  0.08
Output  | 0.00022321 | 0.00022321 | 0.00022321 |   0.0 |  0.00
Modify  | 0.6944     | 0.6944     | 0.6944     |   0.0 |  0.36
Other   |            | 0.1        |            |       |  0.05

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

Total # of neighbors = 311954
Ave neighs/atom = 77.988500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.879446352074, Press = -0.03030089466946
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   94000   -22758.963   -22758.963   -22918.906   -22918.906    309.42125    309.42125    60644.949    60644.949     1378.974     1378.974 
   95000   -22756.658   -22756.658   -22920.036   -22920.036    316.06599    316.06599    60689.244    60689.244   -801.89588   -801.89588 
Loop time of 196.811 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.670 hours/ns, 5.081 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    | 195.86     | 195.86     | 195.86     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14715    | 0.14715    | 0.14715    |   0.0 |  0.07
Output  | 0.00017739 | 0.00017739 | 0.00017739 |   0.0 |  0.00
Modify  | 0.70086    | 0.70086    | 0.70086    |   0.0 |  0.36
Other   |            | 0.1009     |            |       |  0.05

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

Total # of neighbors = 311946
Ave neighs/atom = 77.986500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.881319160444, Press = 0.299808754975712
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   95000   -22756.658   -22756.658   -22920.036   -22920.036    316.06599    316.06599    60689.244    60689.244   -801.89588   -801.89588 
   96000   -22759.799   -22759.799   -22920.803   -22920.803    311.47278    311.47278    60623.901    60623.901    2186.2048    2186.2048 
Loop time of 197.149 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.764 hours/ns, 5.072 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    | 196.2      | 196.2      | 196.2      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14688    | 0.14688    | 0.14688    |   0.0 |  0.07
Output  | 0.00024692 | 0.00024692 | 0.00024692 |   0.0 |  0.00
Modify  | 0.70339    | 0.70339    | 0.70339    |   0.0 |  0.36
Other   |            | 0.1005     |            |       |  0.05

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

Total # of neighbors = 311960
Ave neighs/atom = 77.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 = 312.869761727771, Press = 0.749103075523717
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   96000   -22759.799   -22759.799   -22920.803   -22920.803    311.47278    311.47278    60623.901    60623.901    2186.2048    2186.2048 
   97000    -22754.75    -22754.75   -22917.257   -22917.257    314.38033    314.38033    60650.449    60650.449    1464.8793    1464.8793 
Loop time of 197.458 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.849 hours/ns, 5.064 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    | 196.5      | 196.5      | 196.5      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14781    | 0.14781    | 0.14781    |   0.0 |  0.07
Output  | 0.00024788 | 0.00024788 | 0.00024788 |   0.0 |  0.00
Modify  | 0.70972    | 0.70972    | 0.70972    |   0.0 |  0.36
Other   |            | 0.1011     |            |       |  0.05

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

Total # of neighbors = 311990
Ave neighs/atom = 77.997500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.863601911983, Press = -0.0498813290511442
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   97000    -22754.75    -22754.75   -22917.257   -22917.257    314.38033    314.38033    60650.449    60650.449    1464.8793    1464.8793 
   98000   -22763.145   -22763.145   -22923.477   -22923.477    310.17472    310.17472     60664.44     60664.44   -230.56593   -230.56593 
Loop time of 193.346 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.447 ns/day, 53.707 hours/ns, 5.172 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    | 192.41     | 192.41     | 192.41     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14418    | 0.14418    | 0.14418    |   0.0 |  0.07
Output  | 0.00017642 | 0.00017642 | 0.00017642 |   0.0 |  0.00
Modify  | 0.68944    | 0.68944    | 0.68944    |   0.0 |  0.36
Other   |            | 0.1002     |            |       |  0.05

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

Total # of neighbors = 311952
Ave neighs/atom = 77.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.850782183287, Press = 0.626451985130374
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   98000   -22763.145   -22763.145   -22923.477   -22923.477    310.17472    310.17472     60664.44     60664.44   -230.56593   -230.56593 
   99000   -22760.724   -22760.724   -22922.796   -22922.796    313.53894    313.53894    60640.697    60640.697    1167.4507    1167.4507 
Loop time of 196.558 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.440 ns/day, 54.599 hours/ns, 5.088 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    | 195.61     | 195.61     | 195.61     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14896    | 0.14896    | 0.14896    |   0.0 |  0.08
Output  | 0.00017646 | 0.00017646 | 0.00017646 |   0.0 |  0.00
Modify  | 0.69882    | 0.69882    | 0.69882    |   0.0 |  0.36
Other   |            | 0.0998     |            |       |  0.05

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

Total # of neighbors = 311964
Ave neighs/atom = 77.991000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.855747647852, Press = 0.0679266946885929
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
   99000   -22760.724   -22760.724   -22922.796   -22922.796    313.53894    313.53894    60640.697    60640.697    1167.4507    1167.4507 
  100000   -22758.192   -22758.192   -22919.087   -22919.087    311.26196    311.26196    60717.027    60717.027   -1988.0317   -1988.0317 
Loop time of 196.046 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.441 ns/day, 54.457 hours/ns, 5.101 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    | 195.1      | 195.1      | 195.1      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14646    | 0.14646    | 0.14646    |   0.0 |  0.07
Output  | 0.00022181 | 0.00022181 | 0.00022181 |   0.0 |  0.00
Modify  | 0.69879    | 0.69879    | 0.69879    |   0.0 |  0.36
Other   |            | 0.1007     |            |       |  0.05

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

Total # of neighbors = 311974
Ave neighs/atom = 77.993500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.850029020258, Press = 0.582931991550745
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  100000   -22758.192   -22758.192   -22919.087   -22919.087    311.26196    311.26196    60717.027    60717.027   -1988.0317   -1988.0317 
  101000   -22760.192   -22760.192   -22923.561   -22923.561    316.04899    316.04899    60638.313    60638.313    1206.0877    1206.0877 
Loop time of 197.469 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.853 hours/ns, 5.064 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    | 196.52     | 196.52     | 196.52     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14819    | 0.14819    | 0.14819    |   0.0 |  0.08
Output  | 0.00017577 | 0.00017577 | 0.00017577 |   0.0 |  0.00
Modify  | 0.70151    | 0.70151    | 0.70151    |   0.0 |  0.36
Other   |            | 0.1002     |            |       |  0.05

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

Total # of neighbors = 311970
Ave neighs/atom = 77.992500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.86429344488, Press = 0.313039997229024
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  101000   -22760.192   -22760.192   -22923.561   -22923.561    316.04899    316.04899    60638.313    60638.313    1206.0877    1206.0877 
  102000   -22752.541   -22752.541     -22914.7     -22914.7    313.70724    313.70724    60744.606    60744.606   -2694.3132   -2694.3132 
Loop time of 195.439 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.442 ns/day, 54.289 hours/ns, 5.117 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    | 194.49     | 194.49     | 194.49     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14778    | 0.14778    | 0.14778    |   0.0 |  0.08
Output  | 0.00018025 | 0.00018025 | 0.00018025 |   0.0 |  0.00
Modify  | 0.69677    | 0.69677    | 0.69677    |   0.0 |  0.36
Other   |            | 0.1001     |            |       |  0.05

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

Total # of neighbors = 311954
Ave neighs/atom = 77.988500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.866682050979, Press = -0.094753162109943
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  102000   -22752.541   -22752.541     -22914.7     -22914.7    313.70724    313.70724    60744.606    60744.606   -2694.3132   -2694.3132 
  103000    -22757.47    -22757.47    -22920.53    -22920.53    315.45106    315.45106    60665.766    60665.766     133.1427     133.1427 
Loop time of 197.018 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.439 ns/day, 54.727 hours/ns, 5.076 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    | 196.07     | 196.07     | 196.07     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14666    | 0.14666    | 0.14666    |   0.0 |  0.07
Output  | 0.0002193  | 0.0002193  | 0.0002193  |   0.0 |  0.00
Modify  | 0.70408    | 0.70408    | 0.70408    |   0.0 |  0.36
Other   |            | 0.1008     |            |       |  0.05

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

Total # of neighbors = 311950
Ave neighs/atom = 77.987500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.867517664065, Press = 0.66476796778033
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  103000    -22757.47    -22757.47    -22920.53    -22920.53    315.45106    315.45106    60665.766    60665.766     133.1427     133.1427 
  104000   -22755.188   -22755.188   -22918.496   -22918.496    315.92932    315.92932    60666.464    60666.464    543.74898    543.74898 
Loop time of 198.603 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.168 hours/ns, 5.035 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.65     | 197.65     | 197.65     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14758    | 0.14758    | 0.14758    |   0.0 |  0.07
Output  | 0.00021969 | 0.00021969 | 0.00021969 |   0.0 |  0.00
Modify  | 0.70454    | 0.70454    | 0.70454    |   0.0 |  0.35
Other   |            | 0.1015     |            |       |  0.05

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

Total # of neighbors = 311970
Ave neighs/atom = 77.992500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.884782636625, Press = 0.0734399960753071
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  104000   -22755.188   -22755.188   -22918.496   -22918.496    315.92932    315.92932    60666.464    60666.464    543.74898    543.74898 
  105000   -22758.808   -22758.808    -22917.36    -22917.36    306.72826    306.72826    60662.701    60662.701    709.12687    709.12687 
Loop time of 198.711 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.435 ns/day, 55.198 hours/ns, 5.032 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 197.75     | 197.75     | 197.75     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14873    | 0.14873    | 0.14873    |   0.0 |  0.07
Output  | 0.00017541 | 0.00017541 | 0.00017541 |   0.0 |  0.00
Modify  | 0.71177    | 0.71177    | 0.71177    |   0.0 |  0.36
Other   |            | 0.1015     |            |       |  0.05

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

Total # of neighbors = 311952
Ave neighs/atom = 77.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.891735065065, Press = 0.540882235949046
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  105000   -22758.808   -22758.808    -22917.36    -22917.36    306.72826    306.72826    60662.701    60662.701    709.12687    709.12687 
  106000    -22750.29    -22750.29    -22912.73    -22912.73     314.2522     314.2522    60646.985    60646.985    2184.2901    2184.2901 
Loop time of 197.313 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.809 hours/ns, 5.068 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    | 196.36     | 196.36     | 196.36     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14898    | 0.14898    | 0.14898    |   0.0 |  0.08
Output  | 0.00017907 | 0.00017907 | 0.00017907 |   0.0 |  0.00
Modify  | 0.70599    | 0.70599    | 0.70599    |   0.0 |  0.36
Other   |            | 0.1007     |            |       |  0.05

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

Total # of neighbors = 311952
Ave neighs/atom = 77.988000
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.915061768316, Press = 0.171359564796078
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  106000    -22750.29    -22750.29    -22912.73    -22912.73     314.2522     314.2522    60646.985    60646.985    2184.2901    2184.2901 
  107000   -22757.364   -22757.364   -22919.762   -22919.762    314.17029    314.17029    60684.591    60684.591   -489.46803   -489.46803 
Loop time of 197.449 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.438 ns/day, 54.847 hours/ns, 5.065 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    | 196.5      | 196.5      | 196.5      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14671    | 0.14671    | 0.14671    |   0.0 |  0.07
Output  | 0.00028101 | 0.00028101 | 0.00028101 |   0.0 |  0.00
Modify  | 0.70143    | 0.70143    | 0.70143    |   0.0 |  0.36
Other   |            | 0.101      |            |       |  0.05

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

Total # of neighbors = 311918
Ave neighs/atom = 77.979500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.918061539466, Press = 0.221858729414078
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  107000   -22757.364   -22757.364   -22919.762   -22919.762    314.17029    314.17029    60684.591    60684.591   -489.46803   -489.46803 
  108000   -22753.739   -22753.739    -22917.97    -22917.97    317.71695    317.71695    60674.813    60674.813    233.77339    233.77339 
Loop time of 197.811 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.947 hours/ns, 5.055 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    | 196.85     | 196.85     | 196.85     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14717    | 0.14717    | 0.14717    |   0.0 |  0.07
Output  | 0.00028285 | 0.00028285 | 0.00028285 |   0.0 |  0.00
Modify  | 0.70728    | 0.70728    | 0.70728    |   0.0 |  0.36
Other   |            | 0.102      |            |       |  0.05

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

Total # of neighbors = 311958
Ave neighs/atom = 77.989500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.940054000916, Press = 0.399456807657444
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  108000   -22753.739   -22753.739    -22917.97    -22917.97    317.71695    317.71695    60674.813    60674.813    233.77339    233.77339 
  109000   -22759.536   -22759.536   -22919.535   -22919.535    309.52854    309.52854    60647.771    60647.771     1234.905     1234.905 
Loop time of 198.136 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.038 hours/ns, 5.047 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    | 197.18     | 197.18     | 197.18     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14785    | 0.14785    | 0.14785    |   0.0 |  0.07
Output  | 0.00017523 | 0.00017523 | 0.00017523 |   0.0 |  0.00
Modify  | 0.70662    | 0.70662    | 0.70662    |   0.0 |  0.36
Other   |            | 0.1008     |            |       |  0.05

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

Total # of neighbors = 311966
Ave neighs/atom = 77.991500
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.945456531512, Press = 0.166830902534129
next a
jump SELF top
variable a loop 2000
run 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.5
  ghost atom cutoff = 6.5
  binsize = 3.25, bins = 13 13 13
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6.5
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 4.613 | 4.613 | 4.613 Mbytes
Step TotEng v_etotal_metal PotEng v_pe_metal Temp v_T_metal Volume v_V_metal Press v_P_metal 
  109000   -22759.536   -22759.536   -22919.535   -22919.535    309.52854    309.52854    60647.771    60647.771     1234.905     1234.905 
  110000   -22751.876   -22751.876   -22915.128   -22915.128    315.82208    315.82208    60707.673    60707.673   -888.73466   -888.73466 
Loop time of 199.435 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.399 hours/ns, 5.014 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    | 198.46     | 198.46     | 198.46     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14931    | 0.14931    | 0.14931    |   0.0 |  0.07
Output  | 0.00017685 | 0.00017685 | 0.00017685 |   0.0 |  0.00
Modify  | 0.72011    | 0.72011    | 0.72011    |   0.0 |  0.36
Other   |            | 0.1017     |            |       |  0.05

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

Total # of neighbors = 311960
Ave neighs/atom = 77.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"
jump SELF break

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0