# 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.005 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_PtCo__MO_545073984441_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_545073984441_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 204.509 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.422 ns/day, 56.808 hours/ns, 4.890 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 203.45     | 203.45     | 203.45     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16834    | 0.16834    | 0.16834    |   0.0 |  0.08
Output  | 0.00025666 | 0.00025666 | 0.00025666 |   0.0 |  0.00
Modify  | 0.787      | 0.787      | 0.787      |   0.0 |  0.38
Other   |            | 0.103      |            |       |  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 190.336 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.454 ns/day, 52.871 hours/ns, 5.254 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    | 189.44     | 189.44     | 189.44     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15149    | 0.15149    | 0.15149    |   0.0 |  0.08
Output  | 0.0002601  | 0.0002601  | 0.0002601  |   0.0 |  0.00
Modify  | 0.64921    | 0.64921    | 0.64921    |   0.0 |  0.34
Other   |            | 0.09207    |            |       |  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 217.96 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.396 ns/day, 60.545 hours/ns, 4.588 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    | 216.91     | 216.91     | 216.91     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16698    | 0.16698    | 0.16698    |   0.0 |  0.08
Output  | 0.00031733 | 0.00031733 | 0.00031733 |   0.0 |  0.00
Modify  | 0.78472    | 0.78472    | 0.78472    |   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:      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 201.567 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.991 hours/ns, 4.961 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.61     | 200.61     | 200.61     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15542    | 0.15542    | 0.15542    |   0.0 |  0.08
Output  | 0.00021564 | 0.00021564 | 0.00021564 |   0.0 |  0.00
Modify  | 0.70824    | 0.70824    | 0.70824    |   0.0 |  0.35
Other   |            | 0.09821    |            |       |  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 215.893 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.400 ns/day, 59.970 hours/ns, 4.632 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    | 214.84     | 214.84     | 214.84     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16661    | 0.16661    | 0.16661    |   0.0 |  0.08
Output  | 0.00021777 | 0.00021777 | 0.00021777 |   0.0 |  0.00
Modify  | 0.78082    | 0.78082    | 0.78082    |   0.0 |  0.36
Other   |            | 0.1033     |            |       |  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 210.537 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.410 ns/day, 58.482 hours/ns, 4.750 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    | 209.49     | 209.49     | 209.49     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1635     | 0.1635     | 0.1635     |   0.0 |  0.08
Output  | 0.00019865 | 0.00019865 | 0.00019865 |   0.0 |  0.00
Modify  | 0.77765    | 0.77765    | 0.77765    |   0.0 |  0.37
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:      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 218.576 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.395 ns/day, 60.715 hours/ns, 4.575 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    | 217.48     | 217.48     | 217.48     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16839    | 0.16839    | 0.16839    |   0.0 |  0.08
Output  | 0.00025716 | 0.00025716 | 0.00025716 |   0.0 |  0.00
Modify  | 0.82107    | 0.82107    | 0.82107    |   0.0 |  0.38
Other   |            | 0.1038     |            |       |  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 218.961 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.395 ns/day, 60.822 hours/ns, 4.567 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    | 217.87     | 217.87     | 217.87     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16876    | 0.16876    | 0.16876    |   0.0 |  0.08
Output  | 0.0001764  | 0.0001764  | 0.0001764  |   0.0 |  0.00
Modify  | 0.81819    | 0.81819    | 0.81819    |   0.0 |  0.37
Other   |            | 0.1037     |            |       |  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 221.348 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.390 ns/day, 61.485 hours/ns, 4.518 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    | 220.25     | 220.25     | 220.25     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16719    | 0.16719    | 0.16719    |   0.0 |  0.08
Output  | 0.00022906 | 0.00022906 | 0.00022906 |   0.0 |  0.00
Modify  | 0.82942    | 0.82942    | 0.82942    |   0.0 |  0.37
Other   |            | 0.1054     |            |       |  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 218.759 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.395 ns/day, 60.766 hours/ns, 4.571 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    | 217.66     | 217.66     | 217.66     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16908    | 0.16908    | 0.16908    |   0.0 |  0.08
Output  | 0.00028646 | 0.00028646 | 0.00028646 |   0.0 |  0.00
Modify  | 0.82508    | 0.82508    | 0.82508    |   0.0 |  0.38
Other   |            | 0.1043     |            |       |  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 219.278 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.394 ns/day, 60.911 hours/ns, 4.560 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    | 218.19     | 218.19     | 218.19     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1678     | 0.1678     | 0.1678     |   0.0 |  0.08
Output  | 0.00017818 | 0.00017818 | 0.00017818 |   0.0 |  0.00
Modify  | 0.81665    | 0.81665    | 0.81665    |   0.0 |  0.37
Other   |            | 0.104      |            |       |  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 206.669 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.418 ns/day, 57.408 hours/ns, 4.839 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.65     | 205.65     | 205.65     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15955    | 0.15955    | 0.15955    |   0.0 |  0.08
Output  | 0.00017999 | 0.00017999 | 0.00017999 |   0.0 |  0.00
Modify  | 0.75842    | 0.75842    | 0.75842    |   0.0 |  0.37
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:      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 205.817 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.171 hours/ns, 4.859 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    | 204.8      | 204.8      | 204.8      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15918    | 0.15918    | 0.15918    |   0.0 |  0.08
Output  | 0.00017551 | 0.00017551 | 0.00017551 |   0.0 |  0.00
Modify  | 0.75475    | 0.75475    | 0.75475    |   0.0 |  0.37
Other   |            | 0.09905    |            |       |  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 213.398 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.405 ns/day, 59.277 hours/ns, 4.686 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    | 212.34     | 212.34     | 212.34     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16416    | 0.16416    | 0.16416    |   0.0 |  0.08
Output  | 0.00024486 | 0.00024486 | 0.00024486 |   0.0 |  0.00
Modify  | 0.79304    | 0.79304    | 0.79304    |   0.0 |  0.37
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:      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 218.165 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.396 ns/day, 60.601 hours/ns, 4.584 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    | 217.08     | 217.08     | 217.08     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16748    | 0.16748    | 0.16748    |   0.0 |  0.08
Output  | 0.00044354 | 0.00044354 | 0.00044354 |   0.0 |  0.00
Modify  | 0.81491    | 0.81491    | 0.81491    |   0.0 |  0.37
Other   |            | 0.103      |            |       |  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 217.731 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.397 ns/day, 60.481 hours/ns, 4.593 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    | 216.65     | 216.65     | 216.65     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16577    | 0.16577    | 0.16577    |   0.0 |  0.08
Output  | 0.0001802  | 0.0001802  | 0.0001802  |   0.0 |  0.00
Modify  | 0.81553    | 0.81553    | 0.81553    |   0.0 |  0.37
Other   |            | 0.1045     |            |       |  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 218.023 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.396 ns/day, 60.562 hours/ns, 4.587 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    | 216.93     | 216.93     | 216.93     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16774    | 0.16774    | 0.16774    |   0.0 |  0.08
Output  | 0.00028118 | 0.00028118 | 0.00028118 |   0.0 |  0.00
Modify  | 0.81878    | 0.81878    | 0.81878    |   0.0 |  0.38
Other   |            | 0.1044     |            |       |  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 221.209 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.447 hours/ns, 4.521 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    | 220.11     | 220.11     | 220.11     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16807    | 0.16807    | 0.16807    |   0.0 |  0.08
Output  | 0.00018783 | 0.00018783 | 0.00018783 |   0.0 |  0.00
Modify  | 0.82333    | 0.82333    | 0.82333    |   0.0 |  0.37
Other   |            | 0.1045     |            |       |  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 216.384 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.399 ns/day, 60.107 hours/ns, 4.621 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    | 215.3      | 215.3      | 215.3      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16725    | 0.16725    | 0.16725    |   0.0 |  0.08
Output  | 0.00023216 | 0.00023216 | 0.00023216 |   0.0 |  0.00
Modify  | 0.81647    | 0.81647    | 0.81647    |   0.0 |  0.38
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:      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 204.191 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.720 hours/ns, 4.897 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    | 203.18     | 203.18     | 203.18     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15939    | 0.15939    | 0.15939    |   0.0 |  0.08
Output  | 0.00017946 | 0.00017946 | 0.00017946 |   0.0 |  0.00
Modify  | 0.75058    | 0.75058    | 0.75058    |   0.0 |  0.37
Other   |            | 0.09844    |            |       |  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 209.401 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.413 ns/day, 58.167 hours/ns, 4.776 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    | 208.37     | 208.37     | 208.37     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16136    | 0.16136    | 0.16136    |   0.0 |  0.08
Output  | 0.00023363 | 0.00023363 | 0.00023363 |   0.0 |  0.00
Modify  | 0.77154    | 0.77154    | 0.77154    |   0.0 |  0.37
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:      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 219.361 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.394 ns/day, 60.934 hours/ns, 4.559 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    | 218.27     | 218.27     | 218.27     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16827    | 0.16827    | 0.16827    |   0.0 |  0.08
Output  | 0.00018023 | 0.00018023 | 0.00018023 |   0.0 |  0.00
Modify  | 0.82071    | 0.82071    | 0.82071    |   0.0 |  0.37
Other   |            | 0.1043     |            |       |  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 220.466 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.392 ns/day, 61.240 hours/ns, 4.536 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 219.36     | 219.36     | 219.36     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16675    | 0.16675    | 0.16675    |   0.0 |  0.08
Output  | 0.00022602 | 0.00022602 | 0.00022602 |   0.0 |  0.00
Modify  | 0.82926    | 0.82926    | 0.82926    |   0.0 |  0.38
Other   |            | 0.1055     |            |       |  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 220.774 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.326 hours/ns, 4.530 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 219.68     | 219.68     | 219.68     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16744    | 0.16744    | 0.16744    |   0.0 |  0.08
Output  | 0.00021345 | 0.00021345 | 0.00021345 |   0.0 |  0.00
Modify  | 0.82581    | 0.82581    | 0.82581    |   0.0 |  0.37
Other   |            | 0.1053     |            |       |  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 215.241 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.401 ns/day, 59.789 hours/ns, 4.646 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    | 214.18     | 214.18     | 214.18     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16553    | 0.16553    | 0.16553    |   0.0 |  0.08
Output  | 0.00021831 | 0.00021831 | 0.00021831 |   0.0 |  0.00
Modify  | 0.79553    | 0.79553    | 0.79553    |   0.0 |  0.37
Other   |            | 0.1027     |            |       |  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 221.083 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.412 hours/ns, 4.523 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 219.98     | 219.98     | 219.98     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16709    | 0.16709    | 0.16709    |   0.0 |  0.08
Output  | 0.00023308 | 0.00023308 | 0.00023308 |   0.0 |  0.00
Modify  | 0.82716    | 0.82716    | 0.82716    |   0.0 |  0.37
Other   |            | 0.104      |            |       |  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 216.74 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.399 ns/day, 60.206 hours/ns, 4.614 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    | 215.67     | 215.67     | 215.67     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1667     | 0.1667     | 0.1667     |   0.0 |  0.08
Output  | 0.00026944 | 0.00026944 | 0.00026944 |   0.0 |  0.00
Modify  | 0.80379    | 0.80379    | 0.80379    |   0.0 |  0.37
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:      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 220.803 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.334 hours/ns, 4.529 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    | 219.71     | 219.71     | 219.71     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16602    | 0.16602    | 0.16602    |   0.0 |  0.08
Output  | 0.00017743 | 0.00017743 | 0.00017743 |   0.0 |  0.00
Modify  | 0.82371    | 0.82371    | 0.82371    |   0.0 |  0.37
Other   |            | 0.1045     |            |       |  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 221.931 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.389 ns/day, 61.647 hours/ns, 4.506 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 220.82     | 220.82     | 220.82     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.17035    | 0.17035    | 0.17035    |   0.0 |  0.08
Output  | 0.00023232 | 0.00023232 | 0.00023232 |   0.0 |  0.00
Modify  | 0.83865    | 0.83865    | 0.83865    |   0.0 |  0.38
Other   |            | 0.1055     |            |       |  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 212.619 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.406 ns/day, 59.061 hours/ns, 4.703 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    | 211.57     | 211.57     | 211.57     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16397    | 0.16397    | 0.16397    |   0.0 |  0.08
Output  | 0.00017274 | 0.00017274 | 0.00017274 |   0.0 |  0.00
Modify  | 0.78339    | 0.78339    | 0.78339    |   0.0 |  0.37
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:      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 215.987 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.400 ns/day, 59.996 hours/ns, 4.630 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    | 214.92     | 214.92     | 214.92     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16475    | 0.16475    | 0.16475    |   0.0 |  0.08
Output  | 0.00017514 | 0.00017514 | 0.00017514 |   0.0 |  0.00
Modify  | 0.79711    | 0.79711    | 0.79711    |   0.0 |  0.37
Other   |            | 0.1037     |            |       |  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 222.033 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.389 ns/day, 61.676 hours/ns, 4.504 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 220.93     | 220.93     | 220.93     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16809    | 0.16809    | 0.16809    |   0.0 |  0.08
Output  | 0.00017652 | 0.00017652 | 0.00017652 |   0.0 |  0.00
Modify  | 0.82494    | 0.82494    | 0.82494    |   0.0 |  0.37
Other   |            | 0.1055     |            |       |  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 213.018 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.406 ns/day, 59.172 hours/ns, 4.694 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 211.96     | 211.96     | 211.96     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16413    | 0.16413    | 0.16413    |   0.0 |  0.08
Output  | 0.00017846 | 0.00017846 | 0.00017846 |   0.0 |  0.00
Modify  | 0.78915    | 0.78915    | 0.78915    |   0.0 |  0.37
Other   |            | 0.1027     |            |       |  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 197.591 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.437 ns/day, 54.887 hours/ns, 5.061 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.62     | 196.62     | 196.62     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15441    | 0.15441    | 0.15441    |   0.0 |  0.08
Output  | 0.00017713 | 0.00017713 | 0.00017713 |   0.0 |  0.00
Modify  | 0.71422    | 0.71422    | 0.71422    |   0.0 |  0.36
Other   |            | 0.09823    |            |       |  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 187.48 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.461 ns/day, 52.078 hours/ns, 5.334 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 186.57     | 186.57     | 186.57     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14977    | 0.14977    | 0.14977    |   0.0 |  0.08
Output  | 0.00017854 | 0.00017854 | 0.00017854 |   0.0 |  0.00
Modify  | 0.66336    | 0.66336    | 0.66336    |   0.0 |  0.35
Other   |            | 0.09396    |            |       |  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 213.299 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.405 ns/day, 59.250 hours/ns, 4.688 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    | 212.24     | 212.24     | 212.24     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16425    | 0.16425    | 0.16425    |   0.0 |  0.08
Output  | 0.00017529 | 0.00017529 | 0.00017529 |   0.0 |  0.00
Modify  | 0.79024    | 0.79024    | 0.79024    |   0.0 |  0.37
Other   |            | 0.1018     |            |       |  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 220.522 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.392 ns/day, 61.256 hours/ns, 4.535 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    | 219.42     | 219.42     | 219.42     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16947    | 0.16947    | 0.16947    |   0.0 |  0.08
Output  | 0.00017873 | 0.00017873 | 0.00017873 |   0.0 |  0.00
Modify  | 0.83049    | 0.83049    | 0.83049    |   0.0 |  0.38
Other   |            | 0.104      |            |       |  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 216.243 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.400 ns/day, 60.068 hours/ns, 4.624 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    | 215.17     | 215.17     | 215.17     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16536    | 0.16536    | 0.16536    |   0.0 |  0.08
Output  | 0.00023787 | 0.00023787 | 0.00023787 |   0.0 |  0.00
Modify  | 0.80378    | 0.80378    | 0.80378    |   0.0 |  0.37
Other   |            | 0.1029     |            |       |  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 211.273 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.409 ns/day, 58.687 hours/ns, 4.733 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 210.23     | 210.23     | 210.23     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16153    | 0.16153    | 0.16153    |   0.0 |  0.08
Output  | 0.00018003 | 0.00018003 | 0.00018003 |   0.0 |  0.00
Modify  | 0.77834    | 0.77834    | 0.77834    |   0.0 |  0.37
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:      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 220.768 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.325 hours/ns, 4.530 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 219.66     | 219.66     | 219.66     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16926    | 0.16926    | 0.16926    |   0.0 |  0.08
Output  | 0.00018061 | 0.00018061 | 0.00018061 |   0.0 |  0.00
Modify  | 0.8319     | 0.8319     | 0.8319     |   0.0 |  0.38
Other   |            | 0.1056     |            |       |  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 221.359 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.390 ns/day, 61.489 hours/ns, 4.518 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 220.26     | 220.26     | 220.26     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.168      | 0.168      | 0.168      |   0.0 |  0.08
Output  | 0.00048465 | 0.00048465 | 0.00048465 |   0.0 |  0.00
Modify  | 0.8243     | 0.8243     | 0.8243     |   0.0 |  0.37
Other   |            | 0.1048     |            |       |  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 222.124 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.389 ns/day, 61.701 hours/ns, 4.502 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    | 221.02     | 221.02     | 221.02     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16903    | 0.16903    | 0.16903    |   0.0 |  0.08
Output  | 0.00018277 | 0.00018277 | 0.00018277 |   0.0 |  0.00
Modify  | 0.83137    | 0.83137    | 0.83137    |   0.0 |  0.37
Other   |            | 0.1048     |            |       |  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 221.157 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.433 hours/ns, 4.522 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 220.05     | 220.05     | 220.05     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16869    | 0.16869    | 0.16869    |   0.0 |  0.08
Output  | 0.00018026 | 0.00018026 | 0.00018026 |   0.0 |  0.00
Modify  | 0.83393    | 0.83393    | 0.83393    |   0.0 |  0.38
Other   |            | 0.105      |            |       |  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 220.948 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.374 hours/ns, 4.526 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    | 219.84     | 219.84     | 219.84     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16858    | 0.16858    | 0.16858    |   0.0 |  0.08
Output  | 0.00022856 | 0.00022856 | 0.00022856 |   0.0 |  0.00
Modify  | 0.83205    | 0.83205    | 0.83205    |   0.0 |  0.38
Other   |            | 0.1048     |            |       |  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 198.209 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.436 ns/day, 55.058 hours/ns, 5.045 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.24     | 197.24     | 197.24     |   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.00023016 | 0.00023016 | 0.00023016 |   0.0 |  0.00
Modify  | 0.71416    | 0.71416    | 0.71416    |   0.0 |  0.36
Other   |            | 0.0956     |            |       |  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 212.567 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.406 ns/day, 59.046 hours/ns, 4.704 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    | 211.52     | 211.52     | 211.52     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16344    | 0.16344    | 0.16344    |   0.0 |  0.08
Output  | 0.00017869 | 0.00017869 | 0.00017869 |   0.0 |  0.00
Modify  | 0.78579    | 0.78579    | 0.78579    |   0.0 |  0.37
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:      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 205.665 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.129 hours/ns, 4.862 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    | 204.65     | 204.65     | 204.65     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16189    | 0.16189    | 0.16189    |   0.0 |  0.08
Output  | 0.00018064 | 0.00018064 | 0.00018064 |   0.0 |  0.00
Modify  | 0.75489    | 0.75489    | 0.75489    |   0.0 |  0.37
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.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 204.019 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.423 ns/day, 56.672 hours/ns, 4.902 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.01     | 203.01     | 203.01     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15949    | 0.15949    | 0.15949    |   0.0 |  0.08
Output  | 0.00023328 | 0.00023328 | 0.00023328 |   0.0 |  0.00
Modify  | 0.74631    | 0.74631    | 0.74631    |   0.0 |  0.37
Other   |            | 0.09956    |            |       |  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 192.784 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.448 ns/day, 53.551 hours/ns, 5.187 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    | 191.85     | 191.85     | 191.85     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15185    | 0.15185    | 0.15185    |   0.0 |  0.08
Output  | 0.00018053 | 0.00018053 | 0.00018053 |   0.0 |  0.00
Modify  | 0.6873     | 0.6873     | 0.6873     |   0.0 |  0.36
Other   |            | 0.09639    |            |       |  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 221.187 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.441 hours/ns, 4.521 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    | 220.08     | 220.08     | 220.08     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16968    | 0.16968    | 0.16968    |   0.0 |  0.08
Output  | 0.00017871 | 0.00017871 | 0.00017871 |   0.0 |  0.00
Modify  | 0.83289    | 0.83289    | 0.83289    |   0.0 |  0.38
Other   |            | 0.1057     |            |       |  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 220.263 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.392 ns/day, 61.184 hours/ns, 4.540 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    | 219.16     | 219.16     | 219.16     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16916    | 0.16916    | 0.16916    |   0.0 |  0.08
Output  | 0.00018099 | 0.00018099 | 0.00018099 |   0.0 |  0.00
Modify  | 0.8277     | 0.8277     | 0.8277     |   0.0 |  0.38
Other   |            | 0.1047     |            |       |  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 213.246 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.405 ns/day, 59.235 hours/ns, 4.689 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 212.19     | 212.19     | 212.19     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16479    | 0.16479    | 0.16479    |   0.0 |  0.08
Output  | 0.00021784 | 0.00021784 | 0.00021784 |   0.0 |  0.00
Modify  | 0.78965    | 0.78965    | 0.78965    |   0.0 |  0.37
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:      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 214.938 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.402 ns/day, 59.705 hours/ns, 4.653 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    | 213.87     | 213.87     | 213.87     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16519    | 0.16519    | 0.16519    |   0.0 |  0.08
Output  | 0.0001775  | 0.0001775  | 0.0001775  |   0.0 |  0.00
Modify  | 0.79958    | 0.79958    | 0.79958    |   0.0 |  0.37
Other   |            | 0.1018     |            |       |  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 211.142 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.409 ns/day, 58.650 hours/ns, 4.736 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    | 210.09     | 210.09     | 210.09     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16552    | 0.16552    | 0.16552    |   0.0 |  0.08
Output  | 0.00017818 | 0.00017818 | 0.00017818 |   0.0 |  0.00
Modify  | 0.78586    | 0.78586    | 0.78586    |   0.0 |  0.37
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:      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 192.275 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.449 ns/day, 53.410 hours/ns, 5.201 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.34     | 191.34     | 191.34     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15098    | 0.15098    | 0.15098    |   0.0 |  0.08
Output  | 0.00017679 | 0.00017679 | 0.00017679 |   0.0 |  0.00
Modify  | 0.68371    | 0.68371    | 0.68371    |   0.0 |  0.36
Other   |            | 0.09544    |            |       |  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 193.263 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.447 ns/day, 53.684 hours/ns, 5.174 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.33     | 192.33     | 192.33     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14849    | 0.14849    | 0.14849    |   0.0 |  0.08
Output  | 0.00022021 | 0.00022021 | 0.00022021 |   0.0 |  0.00
Modify  | 0.68871    | 0.68871    | 0.68871    |   0.0 |  0.36
Other   |            | 0.09477    |            |       |  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 203.143 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.429 hours/ns, 4.923 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    | 202.16     | 202.16     | 202.16     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15378    | 0.15378    | 0.15378    |   0.0 |  0.08
Output  | 0.00018094 | 0.00018094 | 0.00018094 |   0.0 |  0.00
Modify  | 0.7338     | 0.7338     | 0.7338     |   0.0 |  0.36
Other   |            | 0.09845    |            |       |  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 187.711 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.460 ns/day, 52.142 hours/ns, 5.327 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    | 186.81     | 186.81     | 186.81     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14614    | 0.14614    | 0.14614    |   0.0 |  0.08
Output  | 0.00018096 | 0.00018096 | 0.00018096 |   0.0 |  0.00
Modify  | 0.66302    | 0.66302    | 0.66302    |   0.0 |  0.35
Other   |            | 0.09286    |            |       |  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 193.764 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.446 ns/day, 53.823 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.83     | 192.83     | 192.83     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14979    | 0.14979    | 0.14979    |   0.0 |  0.08
Output  | 0.00017616 | 0.00017616 | 0.00017616 |   0.0 |  0.00
Modify  | 0.69335    | 0.69335    | 0.69335    |   0.0 |  0.36
Other   |            | 0.09517    |            |       |  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 203.969 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.424 ns/day, 56.658 hours/ns, 4.903 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    | 202.97     | 202.97     | 202.97     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15394    | 0.15394    | 0.15394    |   0.0 |  0.08
Output  | 0.00017727 | 0.00017727 | 0.00017727 |   0.0 |  0.00
Modify  | 0.74183    | 0.74183    | 0.74183    |   0.0 |  0.36
Other   |            | 0.09877    |            |       |  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 213.424 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.405 ns/day, 59.284 hours/ns, 4.686 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 212.37     | 212.37     | 212.37     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1603     | 0.1603     | 0.1603     |   0.0 |  0.08
Output  | 0.00024892 | 0.00024892 | 0.00024892 |   0.0 |  0.00
Modify  | 0.79165    | 0.79165    | 0.79165    |   0.0 |  0.37
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:      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 220.192 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.392 ns/day, 61.164 hours/ns, 4.541 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    | 219.09     | 219.09     | 219.09     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16621    | 0.16621    | 0.16621    |   0.0 |  0.08
Output  | 0.00017638 | 0.00017638 | 0.00017638 |   0.0 |  0.00
Modify  | 0.82811    | 0.82811    | 0.82811    |   0.0 |  0.38
Other   |            | 0.1054     |            |       |  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 210.941 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.410 ns/day, 58.595 hours/ns, 4.741 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    | 209.9      | 209.9      | 209.9      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16028    | 0.16028    | 0.16028    |   0.0 |  0.08
Output  | 0.00017551 | 0.00017551 | 0.00017551 |   0.0 |  0.00
Modify  | 0.77355    | 0.77355    | 0.77355    |   0.0 |  0.37
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:      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 211.586 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.408 ns/day, 58.774 hours/ns, 4.726 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 210.54     | 210.54     | 210.54     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1605     | 0.1605     | 0.1605     |   0.0 |  0.08
Output  | 0.00022576 | 0.00022576 | 0.00022576 |   0.0 |  0.00
Modify  | 0.78204    | 0.78204    | 0.78204    |   0.0 |  0.37
Other   |            | 0.1039     |            |       |  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 216.181 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.400 ns/day, 60.050 hours/ns, 4.626 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    | 215.11     | 215.11     | 215.11     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1635     | 0.1635     | 0.1635     |   0.0 |  0.08
Output  | 0.00022508 | 0.00022508 | 0.00022508 |   0.0 |  0.00
Modify  | 0.80312    | 0.80312    | 0.80312    |   0.0 |  0.37
Other   |            | 0.1042     |            |       |  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 221.036 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.399 hours/ns, 4.524 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    | 219.93     | 219.93     | 219.93     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16667    | 0.16667    | 0.16667    |   0.0 |  0.08
Output  | 0.00022942 | 0.00022942 | 0.00022942 |   0.0 |  0.00
Modify  | 0.83217    | 0.83217    | 0.83217    |   0.0 |  0.38
Other   |            | 0.1055     |            |       |  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 220.727 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.391 ns/day, 61.313 hours/ns, 4.530 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    | 219.63     | 219.63     | 219.63     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16521    | 0.16521    | 0.16521    |   0.0 |  0.07
Output  | 0.00059016 | 0.00059016 | 0.00059016 |   0.0 |  0.00
Modify  | 0.82836    | 0.82836    | 0.82836    |   0.0 |  0.38
Other   |            | 0.1055     |            |       |  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 222.27 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.389 ns/day, 61.742 hours/ns, 4.499 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 221.15     | 221.15     | 221.15     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16655    | 0.16655    | 0.16655    |   0.0 |  0.07
Output  | 0.00022689 | 0.00022689 | 0.00022689 |   0.0 |  0.00
Modify  | 0.84163    | 0.84163    | 0.84163    |   0.0 |  0.38
Other   |            | 0.1064     |            |       |  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 213.227 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.405 ns/day, 59.230 hours/ns, 4.690 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    | 212.17     | 212.17     | 212.17     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16152    | 0.16152    | 0.16152    |   0.0 |  0.08
Output  | 0.00017714 | 0.00017714 | 0.00017714 |   0.0 |  0.00
Modify  | 0.78997    | 0.78997    | 0.78997    |   0.0 |  0.37
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:      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 205.744 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.151 hours/ns, 4.860 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    | 204.74     | 204.74     | 204.74     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15594    | 0.15594    | 0.15594    |   0.0 |  0.08
Output  | 0.0001788  | 0.0001788  | 0.0001788  |   0.0 |  0.00
Modify  | 0.75023    | 0.75023    | 0.75023    |   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:      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 199.485 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.433 ns/day, 55.412 hours/ns, 5.013 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.51     | 198.51     | 198.51     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15281    | 0.15281    | 0.15281    |   0.0 |  0.08
Output  | 0.00017672 | 0.00017672 | 0.00017672 |   0.0 |  0.00
Modify  | 0.72288    | 0.72288    | 0.72288    |   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:      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 221.382 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.390 ns/day, 61.495 hours/ns, 4.517 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 220.28     | 220.28     | 220.28     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16648    | 0.16648    | 0.16648    |   0.0 |  0.08
Output  | 0.00017582 | 0.00017582 | 0.00017582 |   0.0 |  0.00
Modify  | 0.83507    | 0.83507    | 0.83507    |   0.0 |  0.38
Other   |            | 0.1053     |            |       |  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 194.061 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.445 ns/day, 53.906 hours/ns, 5.153 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    | 193.12     | 193.12     | 193.12     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15044    | 0.15044    | 0.15044    |   0.0 |  0.08
Output  | 0.00022359 | 0.00022359 | 0.00022359 |   0.0 |  0.00
Modify  | 0.69206    | 0.69206    | 0.69206    |   0.0 |  0.36
Other   |            | 0.09628    |            |       |  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 201.963 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.101 hours/ns, 4.951 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.97     | 200.97     | 200.97     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1542     | 0.1542     | 0.1542     |   0.0 |  0.08
Output  | 0.00017773 | 0.00017773 | 0.00017773 |   0.0 |  0.00
Modify  | 0.73631    | 0.73631    | 0.73631    |   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.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 205.506 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.420 ns/day, 57.085 hours/ns, 4.866 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 204.5      | 204.5      | 204.5      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15636    | 0.15636    | 0.15636    |   0.0 |  0.08
Output  | 0.00022187 | 0.00022187 | 0.00022187 |   0.0 |  0.00
Modify  | 0.75199    | 0.75199    | 0.75199    |   0.0 |  0.37
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:      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 220.44 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.392 ns/day, 61.233 hours/ns, 4.536 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    | 219.34     | 219.34     | 219.34     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16501    | 0.16501    | 0.16501    |   0.0 |  0.07
Output  | 0.0002835  | 0.0002835  | 0.0002835  |   0.0 |  0.00
Modify  | 0.82737    | 0.82737    | 0.82737    |   0.0 |  0.38
Other   |            | 0.1066     |            |       |  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 222.108 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.389 ns/day, 61.697 hours/ns, 4.502 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 221        | 221        | 221        |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16701    | 0.16701    | 0.16701    |   0.0 |  0.08
Output  | 0.00024759 | 0.00024759 | 0.00024759 |   0.0 |  0.00
Modify  | 0.83645    | 0.83645    | 0.83645    |   0.0 |  0.38
Other   |            | 0.1064     |            |       |  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 201.088 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.858 hours/ns, 4.973 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.11     | 200.11     | 200.11     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15409    | 0.15409    | 0.15409    |   0.0 |  0.08
Output  | 0.00022701 | 0.00022701 | 0.00022701 |   0.0 |  0.00
Modify  | 0.72836    | 0.72836    | 0.72836    |   0.0 |  0.36
Other   |            | 0.09886    |            |       |  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 215.951 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.400 ns/day, 59.986 hours/ns, 4.631 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 214.88     | 214.88     | 214.88     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16201    | 0.16201    | 0.16201    |   0.0 |  0.08
Output  | 0.00017766 | 0.00017766 | 0.00017766 |   0.0 |  0.00
Modify  | 0.80886    | 0.80886    | 0.80886    |   0.0 |  0.37
Other   |            | 0.1042     |            |       |  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 191.23 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.452 ns/day, 53.119 hours/ns, 5.229 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    | 190.3      | 190.3      | 190.3      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14958    | 0.14958    | 0.14958    |   0.0 |  0.08
Output  | 0.00017975 | 0.00017975 | 0.00017975 |   0.0 |  0.00
Modify  | 0.68082    | 0.68082    | 0.68082    |   0.0 |  0.36
Other   |            | 0.09472    |            |       |  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 188.288 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.459 ns/day, 52.302 hours/ns, 5.311 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    | 187.38     | 187.38     | 187.38     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14713    | 0.14713    | 0.14713    |   0.0 |  0.08
Output  | 0.00017856 | 0.00017856 | 0.00017856 |   0.0 |  0.00
Modify  | 0.66736    | 0.66736    | 0.66736    |   0.0 |  0.35
Other   |            | 0.09371    |            |       |  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 187.959 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.460 ns/day, 52.211 hours/ns, 5.320 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    | 187.05     | 187.05     | 187.05     |   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.00021847 | 0.00021847 | 0.00021847 |   0.0 |  0.00
Modify  | 0.66572    | 0.66572    | 0.66572    |   0.0 |  0.35
Other   |            | 0.0942     |            |       |  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 214.05 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.404 ns/day, 59.458 hours/ns, 4.672 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 212.99     | 212.99     | 212.99     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16232    | 0.16232    | 0.16232    |   0.0 |  0.08
Output  | 0.00017662 | 0.00017662 | 0.00017662 |   0.0 |  0.00
Modify  | 0.79287    | 0.79287    | 0.79287    |   0.0 |  0.37
Other   |            | 0.1039     |            |       |  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 201.711 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.031 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.73     | 200.73     | 200.73     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15315    | 0.15315    | 0.15315    |   0.0 |  0.08
Output  | 0.0001775  | 0.0001775  | 0.0001775  |   0.0 |  0.00
Modify  | 0.72823    | 0.72823    | 0.72823    |   0.0 |  0.36
Other   |            | 0.09912    |            |       |  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 188.527 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.458 ns/day, 52.369 hours/ns, 5.304 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    | 187.62     | 187.62     | 187.62     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14744    | 0.14744    | 0.14744    |   0.0 |  0.08
Output  | 0.00017856 | 0.00017856 | 0.00017856 |   0.0 |  0.00
Modify  | 0.66644    | 0.66644    | 0.66644    |   0.0 |  0.35
Other   |            | 0.09456    |            |       |  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 189.212 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.457 ns/day, 52.559 hours/ns, 5.285 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    | 188.3      | 188.3      | 188.3      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14764    | 0.14764    | 0.14764    |   0.0 |  0.08
Output  | 0.0001779  | 0.0001779  | 0.0001779  |   0.0 |  0.00
Modify  | 0.66893    | 0.66893    | 0.66893    |   0.0 |  0.35
Other   |            | 0.09361    |            |       |  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 188.739 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.458 ns/day, 52.427 hours/ns, 5.298 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 187.83     | 187.83     | 187.83     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14776    | 0.14776    | 0.14776    |   0.0 |  0.08
Output  | 0.00021673 | 0.00021673 | 0.00021673 |   0.0 |  0.00
Modify  | 0.66542    | 0.66542    | 0.66542    |   0.0 |  0.35
Other   |            | 0.09444    |            |       |  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 211.839 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.408 ns/day, 58.844 hours/ns, 4.721 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    | 210.79     | 210.79     | 210.79     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15936    | 0.15936    | 0.15936    |   0.0 |  0.08
Output  | 0.00026803 | 0.00026803 | 0.00026803 |   0.0 |  0.00
Modify  | 0.78873    | 0.78873    | 0.78873    |   0.0 |  0.37
Other   |            | 0.1037     |            |       |  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 221.836 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.389 ns/day, 61.621 hours/ns, 4.508 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 220.73     | 220.73     | 220.73     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16463    | 0.16463    | 0.16463    |   0.0 |  0.07
Output  | 0.0001864  | 0.0001864  | 0.0001864  |   0.0 |  0.00
Modify  | 0.83188    | 0.83188    | 0.83188    |   0.0 |  0.37
Other   |            | 0.1058     |            |       |  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 218.171 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.396 ns/day, 60.603 hours/ns, 4.584 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 217.09     | 217.09     | 217.09     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16241    | 0.16241    | 0.16241    |   0.0 |  0.07
Output  | 0.00017772 | 0.00017772 | 0.00017772 |   0.0 |  0.00
Modify  | 0.81112    | 0.81112    | 0.81112    |   0.0 |  0.37
Other   |            | 0.1055     |            |       |  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 207.471 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.416 ns/day, 57.631 hours/ns, 4.820 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    | 206.45     | 206.45     | 206.45     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1561     | 0.1561     | 0.1561     |   0.0 |  0.08
Output  | 0.00023121 | 0.00023121 | 0.00023121 |   0.0 |  0.00
Modify  | 0.76099    | 0.76099    | 0.76099    |   0.0 |  0.37
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.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 215.214 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.401 ns/day, 59.782 hours/ns, 4.647 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    | 214.15     | 214.15     | 214.15     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16237    | 0.16237    | 0.16237    |   0.0 |  0.08
Output  | 0.00028097 | 0.00028097 | 0.00028097 |   0.0 |  0.00
Modify  | 0.79854    | 0.79854    | 0.79854    |   0.0 |  0.37
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:      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 222.44 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.388 ns/day, 61.789 hours/ns, 4.496 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 221.33     | 221.33     | 221.33     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16647    | 0.16647    | 0.16647    |   0.0 |  0.07
Output  | 0.00048453 | 0.00048453 | 0.00048453 |   0.0 |  0.00
Modify  | 0.83822    | 0.83822    | 0.83822    |   0.0 |  0.38
Other   |            | 0.1061     |            |       |  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 207.832 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.416 ns/day, 57.731 hours/ns, 4.812 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 206.81     | 206.81     | 206.81     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15696    | 0.15696    | 0.15696    |   0.0 |  0.08
Output  | 0.00017845 | 0.00017845 | 0.00017845 |   0.0 |  0.00
Modify  | 0.76319    | 0.76319    | 0.76319    |   0.0 |  0.37
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:      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 220.656 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.392 ns/day, 61.293 hours/ns, 4.532 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 219.55     | 219.55     | 219.55     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16713    | 0.16713    | 0.16713    |   0.0 |  0.08
Output  | 0.00017421 | 0.00017421 | 0.00017421 |   0.0 |  0.00
Modify  | 0.8347     | 0.8347     | 0.8347     |   0.0 |  0.38
Other   |            | 0.1062     |            |       |  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 203.267 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.425 ns/day, 56.463 hours/ns, 4.920 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.27     | 202.27     | 202.27     |   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.00023994 | 0.00023994 | 0.00023994 |   0.0 |  0.00
Modify  | 0.74372    | 0.74372    | 0.74372    |   0.0 |  0.37
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:      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 193.622 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.446 ns/day, 53.784 hours/ns, 5.165 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.68     | 192.68     | 192.68     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14989    | 0.14989    | 0.14989    |   0.0 |  0.08
Output  | 0.00027126 | 0.00027126 | 0.00027126 |   0.0 |  0.00
Modify  | 0.69472    | 0.69472    | 0.69472    |   0.0 |  0.36
Other   |            | 0.09659    |            |       |  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 187.334 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.461 ns/day, 52.037 hours/ns, 5.338 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    | 186.43     | 186.43     | 186.43     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14563    | 0.14563    | 0.14563    |   0.0 |  0.08
Output  | 0.00022876 | 0.00022876 | 0.00022876 |   0.0 |  0.00
Modify  | 0.66619    | 0.66619    | 0.66619    |   0.0 |  0.36
Other   |            | 0.09662    |            |       |  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 186.676 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.463 ns/day, 51.855 hours/ns, 5.357 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 185.77     | 185.77     | 185.77     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14427    | 0.14427    | 0.14427    |   0.0 |  0.08
Output  | 0.00022561 | 0.00022561 | 0.00022561 |   0.0 |  0.00
Modify  | 0.66391    | 0.66391    | 0.66391    |   0.0 |  0.36
Other   |            | 0.09714    |            |       |  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 186.758 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.463 ns/day, 51.877 hours/ns, 5.355 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    | 185.85     | 185.85     | 185.85     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1427     | 0.1427     | 0.1427     |   0.0 |  0.08
Output  | 0.00022671 | 0.00022671 | 0.00022671 |   0.0 |  0.00
Modify  | 0.66377    | 0.66377    | 0.66377    |   0.0 |  0.36
Other   |            | 0.09721    |            |       |  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 186.679 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.463 ns/day, 51.855 hours/ns, 5.357 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 185.78     | 185.78     | 185.78     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1427     | 0.1427     | 0.1427     |   0.0 |  0.08
Output  | 0.00017654 | 0.00017654 | 0.00017654 |   0.0 |  0.00
Modify  | 0.66024    | 0.66024    | 0.66024    |   0.0 |  0.35
Other   |            | 0.09638    |            |       |  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 186.541 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.463 ns/day, 51.817 hours/ns, 5.361 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    | 185.64     | 185.64     | 185.64     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14296    | 0.14296    | 0.14296    |   0.0 |  0.08
Output  | 0.000178   | 0.000178   | 0.000178   |   0.0 |  0.00
Modify  | 0.65959    | 0.65959    | 0.65959    |   0.0 |  0.35
Other   |            | 0.09729    |            |       |  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 186.672 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.463 ns/day, 51.853 hours/ns, 5.357 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 185.77     | 185.77     | 185.77     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1435     | 0.1435     | 0.1435     |   0.0 |  0.08
Output  | 0.00022377 | 0.00022377 | 0.00022377 |   0.0 |  0.00
Modify  | 0.65944    | 0.65944    | 0.65944    |   0.0 |  0.35
Other   |            | 0.09648    |            |       |  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 187.998 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.460 ns/day, 52.222 hours/ns, 5.319 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    | 187.09     | 187.09     | 187.09     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14352    | 0.14352    | 0.14352    |   0.0 |  0.08
Output  | 0.00021633 | 0.00021633 | 0.00021633 |   0.0 |  0.00
Modify  | 0.66712    | 0.66712    | 0.66712    |   0.0 |  0.35
Other   |            | 0.09736    |            |       |  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 217.143 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.398 ns/day, 60.318 hours/ns, 4.605 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    | 216.06     | 216.06     | 216.06     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16471    | 0.16471    | 0.16471    |   0.0 |  0.08
Output  | 0.00017562 | 0.00017562 | 0.00017562 |   0.0 |  0.00
Modify  | 0.81594    | 0.81594    | 0.81594    |   0.0 |  0.38
Other   |            | 0.1048     |            |       |  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 187.588 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.461 ns/day, 52.108 hours/ns, 5.331 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    | 186.69     | 186.69     | 186.69     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14427    | 0.14427    | 0.14427    |   0.0 |  0.08
Output  | 0.0001762  | 0.0001762  | 0.0001762  |   0.0 |  0.00
Modify  | 0.66126    | 0.66126    | 0.66126    |   0.0 |  0.35
Other   |            | 0.09547    |            |       |  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 213.718 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.404 ns/day, 59.366 hours/ns, 4.679 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 212.65     | 212.65     | 212.65     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16112    | 0.16112    | 0.16112    |   0.0 |  0.08
Output  | 0.00017666 | 0.00017666 | 0.00017666 |   0.0 |  0.00
Modify  | 0.79793    | 0.79793    | 0.79793    |   0.0 |  0.37
Other   |            | 0.1043     |            |       |  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 187.197 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.462 ns/day, 51.999 hours/ns, 5.342 timesteps/s
100.1% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 186.3      | 186.3      | 186.3      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14341    | 0.14341    | 0.14341    |   0.0 |  0.08
Output  | 0.00017679 | 0.00017679 | 0.00017679 |   0.0 |  0.00
Modify  | 0.66133    | 0.66133    | 0.66133    |   0.0 |  0.35
Other   |            | 0.09649    |            |       |  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 187.046 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.462 ns/day, 51.957 hours/ns, 5.346 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    | 186.15     | 186.15     | 186.15     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1429     | 0.1429     | 0.1429     |   0.0 |  0.08
Output  | 0.00017875 | 0.00017875 | 0.00017875 |   0.0 |  0.00
Modify  | 0.66187    | 0.66187    | 0.66187    |   0.0 |  0.35
Other   |            | 0.09569    |            |       |  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 189.832 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.455 ns/day, 52.731 hours/ns, 5.268 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    | 188.91     | 188.91     | 188.91     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1453     | 0.1453     | 0.1453     |   0.0 |  0.08
Output  | 0.00017827 | 0.00017827 | 0.00017827 |   0.0 |  0.00
Modify  | 0.67605    | 0.67605    | 0.67605    |   0.0 |  0.36
Other   |            | 0.09685    |            |       |  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