# 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.031088903546333*${_u_distance}
variable latticeconst_converted equal 3.031088903546333*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.03108890354633
Lattice spacing in x,y,z = 3.0310889 3.0310889 3.0310889
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (30.310889 30.310889 30.310889)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 2000 atoms
  using lattice units in orthogonal box = (0 0 0) to (30.310889 30.310889 30.310889)
  create_atoms CPU = 0.004 seconds

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

kim_interactions V

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

kim interactions V
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_KimSeolJi_2017_PtV__MO_912978207512_002
pair_coeff * * V
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 50.9415

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

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 27848.129123109 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 293.15*${_u_temperature}
variable temp_converted equal 293.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 293.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 293.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 293.15 293.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  "293.15 - 0.2"
variable      T_up  equal  "293.15 + 0.2"
variable      P_low equal  "0.0 - 0.2"
variable      P_up  equal  "0.0 + 0.2"

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -10524.253     -10524.253     -10600         -10600          293.15         293.15         27848.129      27848.129      2905.3071      2905.3071    
      1000  -10441.898     -10441.898     -10524.384     -10524.384      319.22966      319.22966      28071.997      28071.997     -1746.692      -1746.692     
Loop time of 170.204 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.508 ns/day, 47.279 hours/ns, 5.875 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    | 169.69     | 169.69     | 169.69     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097615   | 0.097615   | 0.097615   |   0.0 |  0.06
Output  | 0.00022351 | 0.00022351 | 0.00022351 |   0.0 |  0.00
Modify  | 0.35166    | 0.35166    | 0.35166    |   0.0 |  0.21
Other   |            | 0.06158    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       128000 ave      128000 max      128000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 128000
Ave neighs/atom = 64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -10441.898     -10441.898     -10524.384     -10524.384      319.22966      319.22966      28071.997      28071.997     -1746.692      -1746.692     
      2000  -10445.504     -10445.504     -10522.254     -10522.254      297.02913      297.02913      28054.604      28054.604     -712.02545     -712.02545    
Loop time of 168.871 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.512 ns/day, 46.909 hours/ns, 5.922 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    | 168.38     | 168.38     | 168.38     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094566   | 0.094566   | 0.094566   |   0.0 |  0.06
Output  | 0.00021341 | 0.00021341 | 0.00021341 |   0.0 |  0.00
Modify  | 0.33565    | 0.33565    | 0.33565    |   0.0 |  0.20
Other   |            | 0.05969    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134178 ave      134178 max      134178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134178
Ave neighs/atom = 67.089
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -10445.504     -10445.504     -10522.254     -10522.254      297.02913      297.02913      28054.604      28054.604     -712.02545     -712.02545    
      3000  -10444.915     -10444.915     -10520.059     -10520.059      290.81275      290.81275      28010.515      28010.515      1791.5446      1791.5446    
Loop time of 169.819 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.509 ns/day, 47.172 hours/ns, 5.889 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    | 169.33     | 169.33     | 169.33     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095331   | 0.095331   | 0.095331   |   0.0 |  0.06
Output  | 0.00024904 | 0.00024904 | 0.00024904 |   0.0 |  0.00
Modify  | 0.33677    | 0.33677    | 0.33677    |   0.0 |  0.20
Other   |            | 0.05913    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134552 ave      134552 max      134552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134552
Ave neighs/atom = 67.276
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -10444.915     -10444.915     -10520.059     -10520.059      290.81275      290.81275      28010.515      28010.515      1791.5446      1791.5446    
      4000  -10444.654     -10444.654     -10517.275     -10517.275      281.04813      281.04813      28040.941      28040.941      192.57328      192.57328    
Loop time of 179.991 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.480 ns/day, 49.998 hours/ns, 5.556 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    | 179.47     | 179.47     | 179.47     |   0.0 | 99.71
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099306   | 0.099306   | 0.099306   |   0.0 |  0.06
Output  | 0.00021299 | 0.00021299 | 0.00021299 |   0.0 |  0.00
Modify  | 0.36229    | 0.36229    | 0.36229    |   0.0 |  0.20
Other   |            | 0.06121    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135268 ave      135268 max      135268 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135268
Ave neighs/atom = 67.634
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -10444.654     -10444.654     -10517.275     -10517.275      281.04813      281.04813      28040.941      28040.941      192.57328      192.57328    
      5000  -10443.647     -10443.647     -10520.943     -10520.943      299.14291      299.14291      28088.505      28088.505     -2260.2648     -2260.2648    
Loop time of 197.531 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.437 ns/day, 54.870 hours/ns, 5.062 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.95     | 196.95     | 196.95     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10663    | 0.10663    | 0.10663    |   0.0 |  0.05
Output  | 0.00016919 | 0.00016919 | 0.00016919 |   0.0 |  0.00
Modify  | 0.41111    | 0.41111    | 0.41111    |   0.0 |  0.21
Other   |            | 0.06509    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135260 ave      135260 max      135260 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135260
Ave neighs/atom = 67.63
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 294.811334487172, Press = -357.223561345095
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -10443.647     -10443.647     -10520.943     -10520.943      299.14291      299.14291      28088.505      28088.505     -2260.2648     -2260.2648    
      6000  -10443.558     -10443.558     -10519.883     -10519.883      295.38841      295.38841      27980.476      27980.476      3507.9573      3507.9573    
Loop time of 174.436 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.495 ns/day, 48.454 hours/ns, 5.733 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    | 173.9      | 173.9      | 173.9      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097079   | 0.097079   | 0.097079   |   0.0 |  0.06
Output  | 0.00020479 | 0.00020479 | 0.00020479 |   0.0 |  0.00
Modify  | 0.37494    | 0.37494    | 0.37494    |   0.0 |  0.21
Other   |            | 0.06181    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134344 ave      134344 max      134344 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134344
Ave neighs/atom = 67.172
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.625270143878, Press = -13.3490647298068
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -10443.558     -10443.558     -10519.883     -10519.883      295.38841      295.38841      27980.476      27980.476      3507.9573      3507.9573    
      7000  -10444.393     -10444.393     -10518.323     -10518.323      286.1155       286.1155       28044.034      28044.034     -70.343898     -70.343898    
Loop time of 196.768 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.658 hours/ns, 5.082 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    | 196.17     | 196.17     | 196.17     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10622    | 0.10622    | 0.10622    |   0.0 |  0.05
Output  | 0.00016757 | 0.00016757 | 0.00016757 |   0.0 |  0.00
Modify  | 0.4229     | 0.4229     | 0.4229     |   0.0 |  0.21
Other   |            | 0.06508    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135340 ave      135340 max      135340 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135340
Ave neighs/atom = 67.67
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 291.785167444732, Press = 31.8755659568526
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -10444.393     -10444.393     -10518.323     -10518.323      286.1155       286.1155       28044.034      28044.034     -70.343898     -70.343898    
      8000  -10444.068     -10444.068     -10518.844     -10518.844      289.39337      289.39337      28061.954      28061.954     -1031.1159     -1031.1159    
Loop time of 195.599 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.442 ns/day, 54.333 hours/ns, 5.112 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    | 195.01     | 195.01     | 195.01     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10599    | 0.10599    | 0.10599    |   0.0 |  0.05
Output  | 0.00021365 | 0.00021365 | 0.00021365 |   0.0 |  0.00
Modify  | 0.42074    | 0.42074    | 0.42074    |   0.0 |  0.22
Other   |            | 0.06459    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135220 ave      135220 max      135220 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135220
Ave neighs/atom = 67.61
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.449502149359, Press = -3.27347487046044
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -10444.068     -10444.068     -10518.844     -10518.844      289.39337      289.39337      28061.954      28061.954     -1031.1159     -1031.1159    
      9000  -10445.215     -10445.215     -10518.575     -10518.575      283.91054      283.91054      28005.631      28005.631      1896.4334      1896.4334    
Loop time of 188.911 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.457 ns/day, 52.475 hours/ns, 5.293 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.32     | 188.32     | 188.32     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1049     | 0.1049     | 0.1049     |   0.0 |  0.06
Output  | 0.00016797 | 0.00016797 | 0.00016797 |   0.0 |  0.00
Modify  | 0.4181     | 0.4181     | 0.4181     |   0.0 |  0.22
Other   |            | 0.06562    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134816 ave      134816 max      134816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134816
Ave neighs/atom = 67.408
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.447026848868, Press = 4.91474401942027
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -10445.215     -10445.215     -10518.575     -10518.575      283.91054      283.91054      28005.631      28005.631      1896.4334      1896.4334    
     10000  -10444.038     -10444.038     -10518.808     -10518.808      289.36818      289.36818      28053.845      28053.845     -706.866       -706.866      
Loop time of 170.824 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.506 ns/day, 47.451 hours/ns, 5.854 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    | 170.31     | 170.31     | 170.31     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095938   | 0.095938   | 0.095938   |   0.0 |  0.06
Output  | 0.00016848 | 0.00016848 | 0.00016848 |   0.0 |  0.00
Modify  | 0.36106    | 0.36106    | 0.36106    |   0.0 |  0.21
Other   |            | 0.06118    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135396 ave      135396 max      135396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135396
Ave neighs/atom = 67.698
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.142324855642, Press = 14.7097610883905
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -10444.038     -10444.038     -10518.808     -10518.808      289.36818      289.36818      28053.845      28053.845     -706.866       -706.866      
     11000  -10445.888     -10445.888     -10523.782     -10523.782      301.45915      301.45915      28079.498      28079.498     -2308.2741     -2308.2741    
Loop time of 195.788 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.441 ns/day, 54.386 hours/ns, 5.108 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.19     | 195.19     | 195.19     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10613    | 0.10613    | 0.10613    |   0.0 |  0.05
Output  | 0.00022846 | 0.00022846 | 0.00022846 |   0.0 |  0.00
Modify  | 0.42946    | 0.42946    | 0.42946    |   0.0 |  0.22
Other   |            | 0.06518    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135000 ave      135000 max      135000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135000
Ave neighs/atom = 67.5
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.317026486114, Press = -8.14702138436728
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -10445.888     -10445.888     -10523.782     -10523.782      301.45915      301.45915      28079.498      28079.498     -2308.2741     -2308.2741    
     12000  -10444.102     -10444.102     -10521.713     -10521.713      300.36274      300.36274      27991.592      27991.592      2546.5315      2546.5315    
Loop time of 197.051 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.438 ns/day, 54.736 hours/ns, 5.075 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.44     | 196.44     | 196.44     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10664    | 0.10664    | 0.10664    |   0.0 |  0.05
Output  | 0.00016847 | 0.00016847 | 0.00016847 |   0.0 |  0.00
Modify  | 0.43632    | 0.43632    | 0.43632    |   0.0 |  0.22
Other   |            | 0.06651    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134440 ave      134440 max      134440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134440
Ave neighs/atom = 67.22
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.174930294946, Press = 2.50568664745801
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -10444.102     -10444.102     -10521.713     -10521.713      300.36274      300.36274      27991.592      27991.592      2546.5315      2546.5315    
     13000  -10445.412     -10445.412     -10519.738     -10519.738      287.64742      287.64742      28051.289      28051.289     -374.52356     -374.52356    
Loop time of 197.233 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.438 ns/day, 54.787 hours/ns, 5.070 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.64     | 196.64     | 196.64     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10495    | 0.10495    | 0.10495    |   0.0 |  0.05
Output  | 0.0001685  | 0.0001685  | 0.0001685  |   0.0 |  0.00
Modify  | 0.42517    | 0.42517    | 0.42517    |   0.0 |  0.22
Other   |            | 0.06494    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135274 ave      135274 max      135274 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135274
Ave neighs/atom = 67.637
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 291.984426646955, Press = 7.18949675586921
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -10445.412     -10445.412     -10519.738     -10519.738      287.64742      287.64742      28051.289      28051.289     -374.52356     -374.52356    
     14000  -10445.681     -10445.681     -10523.122     -10523.122      299.70788      299.70788      28054.836      28054.836     -838.22932     -838.22932    
Loop time of 197.085 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.438 ns/day, 54.746 hours/ns, 5.074 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.47     | 196.47     | 196.47     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10779    | 0.10779    | 0.10779    |   0.0 |  0.05
Output  | 0.00023201 | 0.00023201 | 0.00023201 |   0.0 |  0.00
Modify  | 0.43875    | 0.43875    | 0.43875    |   0.0 |  0.22
Other   |            | 0.06594    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134786 ave      134786 max      134786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134786
Ave neighs/atom = 67.393
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.046208520068, Press = 0.727381104619603
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -10445.681     -10445.681     -10523.122     -10523.122      299.70788      299.70788      28054.836      28054.836     -838.22932     -838.22932    
     15000  -10442.001     -10442.001     -10518.761     -10518.761      297.06797      297.06797      28027.946      28027.946      1032.4998      1032.4998    
Loop time of 170.193 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.508 ns/day, 47.276 hours/ns, 5.876 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    | 169.68     | 169.68     | 169.68     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095372   | 0.095372   | 0.095372   |   0.0 |  0.06
Output  | 0.00016836 | 0.00016836 | 0.00016836 |   0.0 |  0.00
Modify  | 0.35837    | 0.35837    | 0.35837    |   0.0 |  0.21
Other   |            | 0.05908    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134314 ave      134314 max      134314 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134314
Ave neighs/atom = 67.157
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.106830915851, Press = 2.27201619825322
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -10442.001     -10442.001     -10518.761     -10518.761      297.06797      297.06797      28027.946      28027.946      1032.4998      1032.4998    
     16000  -10445.779     -10445.779     -10522.298     -10522.298      296.13401      296.13401      28046.335      28046.335     -313.45634     -313.45634    
Loop time of 169.953 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.508 ns/day, 47.209 hours/ns, 5.884 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    | 169.44     | 169.44     | 169.44     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095976   | 0.095976   | 0.095976   |   0.0 |  0.06
Output  | 0.00017002 | 0.00017002 | 0.00017002 |   0.0 |  0.00
Modify  | 0.35773    | 0.35773    | 0.35773    |   0.0 |  0.21
Other   |            | 0.0597     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135158 ave      135158 max      135158 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135158
Ave neighs/atom = 67.579
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.114083422807, Press = 7.51217948131607
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -10445.779     -10445.779     -10522.298     -10522.298      296.13401      296.13401      28046.335      28046.335     -313.45634     -313.45634    
     17000  -10443.312     -10443.312     -10518.671     -10518.671      291.64642      291.64642      28088.557      28088.557     -2453.681      -2453.681     
Loop time of 169.881 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.509 ns/day, 47.189 hours/ns, 5.886 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    | 169.37     | 169.37     | 169.37     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095517   | 0.095517   | 0.095517   |   0.0 |  0.06
Output  | 0.00017105 | 0.00017105 | 0.00017105 |   0.0 |  0.00
Modify  | 0.35836    | 0.35836    | 0.35836    |   0.0 |  0.21
Other   |            | 0.05897    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134786 ave      134786 max      134786 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134786
Ave neighs/atom = 67.393
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.063929796766, Press = -2.41602854912015
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -10443.312     -10443.312     -10518.671     -10518.671      291.64642      291.64642      28088.557      28088.557     -2453.681      -2453.681     
     18000  -10443.305     -10443.305     -10518.219     -10518.219      289.92459      289.92459      28003.774      28003.774      2140.834       2140.834     
Loop time of 169.767 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.509 ns/day, 47.157 hours/ns, 5.890 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    | 169.25     | 169.25     | 169.25     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096475   | 0.096475   | 0.096475   |   0.0 |  0.06
Output  | 0.00020163 | 0.00020163 | 0.00020163 |   0.0 |  0.00
Modify  | 0.35922    | 0.35922    | 0.35922    |   0.0 |  0.21
Other   |            | 0.05888    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134552 ave      134552 max      134552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134552
Ave neighs/atom = 67.276
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.013528258351, Press = 0.609188757445904
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -10443.305     -10443.305     -10518.219     -10518.219      289.92459      289.92459      28003.774      28003.774      2140.834       2140.834     
     19000  -10445.361     -10445.361     -10521.933     -10521.933      296.33925      296.33925      28042.712      28042.712     -169.75689     -169.75689    
Loop time of 170.132 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.508 ns/day, 47.259 hours/ns, 5.878 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 169.62     | 169.62     | 169.62     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095662   | 0.095662   | 0.095662   |   0.0 |  0.06
Output  | 0.0001714  | 0.0001714  | 0.0001714  |   0.0 |  0.00
Modify  | 0.35822    | 0.35822    | 0.35822    |   0.0 |  0.21
Other   |            | 0.05889    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135242 ave      135242 max      135242 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135242
Ave neighs/atom = 67.621
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.159304980965, Press = 4.32351559972396
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -10445.361     -10445.361     -10521.933     -10521.933      296.33925      296.33925      28042.712      28042.712     -169.75689     -169.75689    
     20000  -10442.812     -10442.812     -10520.31      -10520.31       299.92389      299.92389      28064.914      28064.914     -1211.5281     -1211.5281    
Loop time of 169.933 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.508 ns/day, 47.204 hours/ns, 5.885 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    | 169.42     | 169.42     | 169.42     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095898   | 0.095898   | 0.095898   |   0.0 |  0.06
Output  | 0.00016785 | 0.00016785 | 0.00016785 |   0.0 |  0.00
Modify  | 0.35873    | 0.35873    | 0.35873    |   0.0 |  0.21
Other   |            | 0.05925    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134750 ave      134750 max      134750 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134750
Ave neighs/atom = 67.375
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.304515270434, Press = 0.912725039768205
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -10442.812     -10442.812     -10520.31      -10520.31       299.92389      299.92389      28064.914      28064.914     -1211.5281     -1211.5281    
     21000  -10448.6       -10448.6       -10522.1       -10522.1        284.45463      284.45463      28031.574      28031.574      284.35386      284.35386    
Loop time of 170.466 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.507 ns/day, 47.352 hours/ns, 5.866 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    | 169.95     | 169.95     | 169.95     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096207   | 0.096207   | 0.096207   |   0.0 |  0.06
Output  | 0.00020807 | 0.00020807 | 0.00020807 |   0.0 |  0.00
Modify  | 0.36032    | 0.36032    | 0.36032    |   0.0 |  0.21
Other   |            | 0.0594     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134716 ave      134716 max      134716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134716
Ave neighs/atom = 67.358
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.287924920127, Press = 0.983031261940285
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -10448.6       -10448.6       -10522.1       -10522.1        284.45463      284.45463      28031.574      28031.574      284.35386      284.35386    
     22000  -10444.07      -10444.07      -10521.214     -10521.214      298.55713      298.55713      28040.419      28040.419      38.807177      38.807177    
Loop time of 170.458 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.507 ns/day, 47.349 hours/ns, 5.867 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    | 169.94     | 169.94     | 169.94     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095851   | 0.095851   | 0.095851   |   0.0 |  0.06
Output  | 0.00019953 | 0.00019953 | 0.00019953 |   0.0 |  0.00
Modify  | 0.35864    | 0.35864    | 0.35864    |   0.0 |  0.21
Other   |            | 0.05953    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134884 ave      134884 max      134884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134884
Ave neighs/atom = 67.442
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.22222119374, Press = 1.31729828983212
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -10444.07      -10444.07      -10521.214     -10521.214      298.55713      298.55713      28040.419      28040.419      38.807177      38.807177    
     23000  -10444.808     -10444.808     -10519.417     -10519.417      288.74252      288.74252      28046.712      28046.712     -174.57973     -174.57973    
Loop time of 170.347 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.507 ns/day, 47.319 hours/ns, 5.870 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    | 169.83     | 169.83     | 169.83     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095425   | 0.095425   | 0.095425   |   0.0 |  0.06
Output  | 0.00016831 | 0.00016831 | 0.00016831 |   0.0 |  0.00
Modify  | 0.35905    | 0.35905    | 0.35905    |   0.0 |  0.21
Other   |            | 0.05852    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134752 ave      134752 max      134752 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134752
Ave neighs/atom = 67.376
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.24737480619, Press = 1.23983299718397
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -10444.808     -10444.808     -10519.417     -10519.417      288.74252      288.74252      28046.712      28046.712     -174.57973     -174.57973    
     24000  -10441.025     -10441.025     -10518.917     -10518.917      301.44957      301.44957      28052.009      28052.009     -263.78852     -263.78852    
Loop time of 170.2 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.508 ns/day, 47.278 hours/ns, 5.875 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    | 169.69     | 169.69     | 169.69     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096149   | 0.096149   | 0.096149   |   0.0 |  0.06
Output  | 0.00016932 | 0.00016932 | 0.00016932 |   0.0 |  0.00
Modify  | 0.35806    | 0.35806    | 0.35806    |   0.0 |  0.21
Other   |            | 0.05881    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134872 ave      134872 max      134872 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134872
Ave neighs/atom = 67.436
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.423572020345, Press = 0.450507379541569
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -10441.025     -10441.025     -10518.917     -10518.917      301.44957      301.44957      28052.009      28052.009     -263.78852     -263.78852    
     25000  -10445.633     -10445.633     -10521.212     -10521.212      292.49636      292.49636      28012.517      28012.517      1474.9442      1474.9442    
Loop time of 169.972 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.508 ns/day, 47.215 hours/ns, 5.883 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    | 169.46     | 169.46     | 169.46     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09532    | 0.09532    | 0.09532    |   0.0 |  0.06
Output  | 0.00017062 | 0.00017062 | 0.00017062 |   0.0 |  0.00
Modify  | 0.35678    | 0.35678    | 0.35678    |   0.0 |  0.21
Other   |            | 0.05916    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134820 ave      134820 max      134820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134820
Ave neighs/atom = 67.41
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.56584291915, Press = 1.07916669018423
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -10445.633     -10445.633     -10521.212     -10521.212      292.49636      292.49636      28012.517      28012.517      1474.9442      1474.9442    
     26000  -10446.806     -10446.806     -10521.676     -10521.676      289.75263      289.75263      28062.175      28062.175     -1282.0846     -1282.0846    
Loop time of 187.524 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.461 ns/day, 52.090 hours/ns, 5.333 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.94     | 186.94     | 186.94     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10439    | 0.10439    | 0.10439    |   0.0 |  0.06
Output  | 0.00021256 | 0.00021256 | 0.00021256 |   0.0 |  0.00
Modify  | 0.41488    | 0.41488    | 0.41488    |   0.0 |  0.22
Other   |            | 0.0646     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134920 ave      134920 max      134920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134920
Ave neighs/atom = 67.46
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.635679347006, Press = 2.81758880219023
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -10446.806     -10446.806     -10521.676     -10521.676      289.75263      289.75263      28062.175      28062.175     -1282.0846     -1282.0846    
     27000  -10444.558     -10444.558     -10520.82      -10520.82       295.14542      295.14542      28050.7        28050.7       -529.1019      -529.1019     
Loop time of 196.815 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.671 hours/ns, 5.081 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.2      | 196.2      | 196.2      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10707    | 0.10707    | 0.10707    |   0.0 |  0.05
Output  | 0.0002444  | 0.0002444  | 0.0002444  |   0.0 |  0.00
Modify  | 0.44245    | 0.44245    | 0.44245    |   0.0 |  0.22
Other   |            | 0.06673    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134596 ave      134596 max      134596 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134596
Ave neighs/atom = 67.298
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.546732515072, Press = -2.01525048098109
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -10444.558     -10444.558     -10520.82      -10520.82       295.14542      295.14542      28050.7        28050.7       -529.1019      -529.1019     
     28000  -10445.706     -10445.706     -10522.136     -10522.136      295.79139      295.79139      27991.107      27991.107      2679.4266      2679.4266    
Loop time of 196.99 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.720 hours/ns, 5.076 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    | 196.38     | 196.38     | 196.38     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10594    | 0.10594    | 0.10594    |   0.0 |  0.05
Output  | 0.00021302 | 0.00021302 | 0.00021302 |   0.0 |  0.00
Modify  | 0.44133    | 0.44133    | 0.44133    |   0.0 |  0.22
Other   |            | 0.06609    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134714 ave      134714 max      134714 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134714
Ave neighs/atom = 67.357
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.597533026125, Press = 1.74859239212113
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -10445.706     -10445.706     -10522.136     -10522.136      295.79139      295.79139      27991.107      27991.107      2679.4266      2679.4266    
     29000  -10442.048     -10442.048     -10521.002     -10521.002      305.55742      305.55742      28074.571      28074.571     -1744.2163     -1744.2163    
Loop time of 186.871 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.462 ns/day, 51.909 hours/ns, 5.351 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    | 186.3      | 186.3      | 186.3      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10233    | 0.10233    | 0.10233    |   0.0 |  0.05
Output  | 0.00017006 | 0.00017006 | 0.00017006 |   0.0 |  0.00
Modify  | 0.40907    | 0.40907    | 0.40907    |   0.0 |  0.22
Other   |            | 0.06383    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135042 ave      135042 max      135042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135042
Ave neighs/atom = 67.521
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.627498735716, Press = 2.22007725091554
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -10442.048     -10442.048     -10521.002     -10521.002      305.55742      305.55742      28074.571      28074.571     -1744.2163     -1744.2163    
     30000  -10444.616     -10444.616     -10521.216     -10521.216      296.45181      296.45181      28045.487      28045.487     -369.80135     -369.80135    
Loop time of 168.914 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.512 ns/day, 46.920 hours/ns, 5.920 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    | 168.4      | 168.4      | 168.4      |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09265    | 0.09265    | 0.09265    |   0.0 |  0.05
Output  | 0.0001686  | 0.0001686  | 0.0001686  |   0.0 |  0.00
Modify  | 0.35564    | 0.35564    | 0.35564    |   0.0 |  0.21
Other   |            | 0.06032    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134558 ave      134558 max      134558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134558
Ave neighs/atom = 67.279
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.660244666029, Press = -0.689969540185267
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -10444.616     -10444.616     -10521.216     -10521.216      296.45181      296.45181      28045.487      28045.487     -369.80135     -369.80135    
     31000  -10447.761     -10447.761     -10524.137     -10524.137      295.58402      295.58402      28026.571      28026.571      486.15387      486.15387    
Loop time of 168.954 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 46.932 hours/ns, 5.919 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    | 168.45     | 168.45     | 168.45     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09347    | 0.09347    | 0.09347    |   0.0 |  0.06
Output  | 0.00017024 | 0.00017024 | 0.00017024 |   0.0 |  0.00
Modify  | 0.35575    | 0.35575    | 0.35575    |   0.0 |  0.21
Other   |            | 0.05968    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134760 ave      134760 max      134760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134760
Ave neighs/atom = 67.38
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.595193376649, Press = 1.31765473523878
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -10447.761     -10447.761     -10524.137     -10524.137      295.58402      295.58402      28026.571      28026.571      486.15387      486.15387    
     32000  -10442.955     -10442.955     -10518.592     -10518.592      292.722        292.722        28063.133      28063.133     -952.81865     -952.81865    
Loop time of 181.894 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.475 ns/day, 50.526 hours/ns, 5.498 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    | 181.35     | 181.35     | 181.35     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097682   | 0.097682   | 0.097682   |   0.0 |  0.05
Output  | 0.00016873 | 0.00016873 | 0.00016873 |   0.0 |  0.00
Modify  | 0.38414    | 0.38414    | 0.38414    |   0.0 |  0.21
Other   |            | 0.06073    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134488 ave      134488 max      134488 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134488
Ave neighs/atom = 67.244
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.569322380931, Press = 0.904983822686904
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -10442.955     -10442.955     -10518.592     -10518.592      292.722        292.722        28063.133      28063.133     -952.81865     -952.81865    
     33000  -10449.81      -10449.81      -10523.321     -10523.321      284.49699      284.49699      28015.424      28015.424      1148.9163      1148.9163    
Loop time of 197.846 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.437 ns/day, 54.957 hours/ns, 5.054 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    | 197.23     | 197.23     | 197.23     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10691    | 0.10691    | 0.10691    |   0.0 |  0.05
Output  | 0.00027803 | 0.00027803 | 0.00027803 |   0.0 |  0.00
Modify  | 0.44405    | 0.44405    | 0.44405    |   0.0 |  0.22
Other   |            | 0.06594    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134702 ave      134702 max      134702 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134702
Ave neighs/atom = 67.351
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.522453444978, Press = -0.850047600049958
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -10449.81      -10449.81      -10523.321     -10523.321      284.49699      284.49699      28015.424      28015.424      1148.9163      1148.9163    
     34000  -10443.218     -10443.218     -10519.089     -10519.089      293.62882      293.62882      28007.022      28007.022      1852.9105      1852.9105    
Loop time of 198.055 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.436 ns/day, 55.015 hours/ns, 5.049 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    | 197.46     | 197.46     | 197.46     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10404    | 0.10404    | 0.10404    |   0.0 |  0.05
Output  | 0.00017199 | 0.00017199 | 0.00017199 |   0.0 |  0.00
Modify  | 0.4243     | 0.4243     | 0.4243     |   0.0 |  0.21
Other   |            | 0.06443    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134776 ave      134776 max      134776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134776
Ave neighs/atom = 67.388
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.50583248295, Press = 3.11419317778098
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -10443.218     -10443.218     -10519.089     -10519.089      293.62882      293.62882      28007.022      28007.022      1852.9105      1852.9105    
     35000  -10443.11      -10443.11      -10519.943     -10519.943      297.35309      297.35309      28087.799      28087.799     -2422.1651     -2422.1651    
Loop time of 198.413 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.435 ns/day, 55.115 hours/ns, 5.040 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    | 197.79     | 197.79     | 197.79     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1076     | 0.1076     | 0.1076     |   0.0 |  0.05
Output  | 0.00016854 | 0.00016854 | 0.00016854 |   0.0 |  0.00
Modify  | 0.44525    | 0.44525    | 0.44525    |   0.0 |  0.22
Other   |            | 0.06618    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135408 ave      135408 max      135408 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135408
Ave neighs/atom = 67.704
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.528933719408, Press = 0.786057711122415
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -10443.11      -10443.11      -10519.943     -10519.943      297.35309      297.35309      28087.799      28087.799     -2422.1651     -2422.1651    
     36000  -10444.653     -10444.653     -10520.862     -10520.862      294.93677      294.93677      28031.08       28031.08       572.8345       572.8345     
Loop time of 195.632 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.442 ns/day, 54.342 hours/ns, 5.112 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.02     | 195.02     | 195.02     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10586    | 0.10586    | 0.10586    |   0.0 |  0.05
Output  | 0.00025453 | 0.00025453 | 0.00025453 |   0.0 |  0.00
Modify  | 0.43857    | 0.43857    | 0.43857    |   0.0 |  0.22
Other   |            | 0.06683    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134566 ave      134566 max      134566 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134566
Ave neighs/atom = 67.283
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.580562438361, Press = -0.43476097535316
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -10444.653     -10444.653     -10520.862     -10520.862      294.93677      294.93677      28031.08       28031.08       572.8345       572.8345     
     37000  -10443.859     -10443.859     -10521.504     -10521.504      300.49652      300.49652      28039.942      28039.942      165.30524      165.30524    
Loop time of 197.556 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.437 ns/day, 54.877 hours/ns, 5.062 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    | 196.94     | 196.94     | 196.94     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10595    | 0.10595    | 0.10595    |   0.0 |  0.05
Output  | 0.0002341  | 0.0002341  | 0.0002341  |   0.0 |  0.00
Modify  | 0.44175    | 0.44175    | 0.44175    |   0.0 |  0.22
Other   |            | 0.06613    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134964 ave      134964 max      134964 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134964
Ave neighs/atom = 67.482
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.587247976846, Press = 1.3349171808405
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -10443.859     -10443.859     -10521.504     -10521.504      300.49652      300.49652      28039.942      28039.942      165.30524      165.30524    
     38000  -10445.185     -10445.185     -10520.745     -10520.745      292.42612      292.42612      28048.258      28048.258     -557.14864     -557.14864    
Loop time of 197.527 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.437 ns/day, 54.869 hours/ns, 5.063 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    | 196.93     | 196.93     | 196.93     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10385    | 0.10385    | 0.10385    |   0.0 |  0.05
Output  | 0.00066158 | 0.00066158 | 0.00066158 |   0.0 |  0.00
Modify  | 0.42518    | 0.42518    | 0.42518    |   0.0 |  0.22
Other   |            | 0.0651     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134788 ave      134788 max      134788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134788
Ave neighs/atom = 67.394
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.574823224041, Press = 0.296511663565674
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -10445.185     -10445.185     -10520.745     -10520.745      292.42612      292.42612      28048.258      28048.258     -557.14864     -557.14864    
     39000  -10443.968     -10443.968     -10520.599     -10520.599      296.57223      296.57223      28032.327      28032.327      343.10656      343.10656    
Loop time of 198.087 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.436 ns/day, 55.024 hours/ns, 5.048 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    | 197.47     | 197.47     | 197.47     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10816    | 0.10816    | 0.10816    |   0.0 |  0.05
Output  | 0.00017013 | 0.00017013 | 0.00017013 |   0.0 |  0.00
Modify  | 0.44549    | 0.44549    | 0.44549    |   0.0 |  0.22
Other   |            | 0.06681    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134888 ave      134888 max      134888 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134888
Ave neighs/atom = 67.444
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.586993508518, Press = 0.236823895835779
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -10443.968     -10443.968     -10520.599     -10520.599      296.57223      296.57223      28032.327      28032.327      343.10656      343.10656    
     40000  -10446.883     -10446.883     -10521.758     -10521.758      289.77492      289.77492      28037.574      28037.574     -71.213003     -71.213003    
Loop time of 198.522 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.435 ns/day, 55.145 hours/ns, 5.037 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    | 197.92     | 197.92     | 197.92     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10651    | 0.10651    | 0.10651    |   0.0 |  0.05
Output  | 0.00016879 | 0.00016879 | 0.00016879 |   0.0 |  0.00
Modify  | 0.43371    | 0.43371    | 0.43371    |   0.0 |  0.22
Other   |            | 0.06574    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135178 ave      135178 max      135178 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135178
Ave neighs/atom = 67.589
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.544968299598, Press = 1.07898910949766
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -10446.883     -10446.883     -10521.758     -10521.758      289.77492      289.77492      28037.574      28037.574     -71.213003     -71.213003    
     41000  -10443.042     -10443.042     -10518.932     -10518.932      293.69917      293.69917      28074.06       28074.06      -1729.6252     -1729.6252    
Loop time of 198.259 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.436 ns/day, 55.072 hours/ns, 5.044 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    | 197.64     | 197.64     | 197.64     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1071     | 0.1071     | 0.1071     |   0.0 |  0.05
Output  | 0.00023729 | 0.00023729 | 0.00023729 |   0.0 |  0.00
Modify  | 0.44139    | 0.44139    | 0.44139    |   0.0 |  0.22
Other   |            | 0.06596    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134926 ave      134926 max      134926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134926
Ave neighs/atom = 67.463
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.571876798358, Press = -0.451801362308293
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -10443.042     -10443.042     -10518.932     -10518.932      293.69917      293.69917      28074.06       28074.06      -1729.6252     -1729.6252    
     42000  -10443.769     -10443.769     -10521.132     -10521.132      299.40249      299.40249      27989.93       27989.93       2737.3839      2737.3839    
Loop time of 198.133 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.436 ns/day, 55.037 hours/ns, 5.047 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    | 197.54     | 197.54     | 197.54     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1046     | 0.1046     | 0.1046     |   0.0 |  0.05
Output  | 0.00028332 | 0.00028332 | 0.00028332 |   0.0 |  0.00
Modify  | 0.426      | 0.426      | 0.426      |   0.0 |  0.22
Other   |            | 0.06384    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134708 ave      134708 max      134708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134708
Ave neighs/atom = 67.354
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.618752001924, Press = -0.461886907659643
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -10443.769     -10443.769     -10521.132     -10521.132      299.40249      299.40249      27989.93       27989.93       2737.3839      2737.3839    
     43000  -10441.778     -10441.778     -10518.924     -10518.924      298.5631       298.5631       28041.571      28041.571      200.4876       200.4876     
Loop time of 180.747 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.478 ns/day, 50.208 hours/ns, 5.533 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 180.19     | 180.19     | 180.19     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.098539   | 0.098539   | 0.098539   |   0.0 |  0.05
Output  | 0.00016603 | 0.00016603 | 0.00016603 |   0.0 |  0.00
Modify  | 0.39376    | 0.39376    | 0.39376    |   0.0 |  0.22
Other   |            | 0.06204    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135196 ave      135196 max      135196 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135196
Ave neighs/atom = 67.598
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.724712403898, Press = 2.18800139630393
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -10441.778     -10441.778     -10518.924     -10518.924      298.5631       298.5631       28041.571      28041.571      200.4876       200.4876     
     44000  -10445.116     -10445.116     -10520.532     -10520.532      291.86837      291.86837      28069.661      28069.661     -1468.5241     -1468.5241    
Loop time of 169.178 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 46.994 hours/ns, 5.911 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    | 168.67     | 168.67     | 168.67     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093533   | 0.093533   | 0.093533   |   0.0 |  0.06
Output  | 0.00016843 | 0.00016843 | 0.00016843 |   0.0 |  0.00
Modify  | 0.35609    | 0.35609    | 0.35609    |   0.0 |  0.21
Other   |            | 0.06001    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135124 ave      135124 max      135124 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135124
Ave neighs/atom = 67.562
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.757180206653, Press = -0.306682716872256
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -10445.116     -10445.116     -10520.532     -10520.532      291.86837      291.86837      28069.661      28069.661     -1468.5241     -1468.5241    
     45000  -10441.254     -10441.254     -10517.887     -10517.887      296.57885      296.57885      28017.347      28017.347      1635.5041      1635.5041    
Loop time of 169.253 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.015 hours/ns, 5.908 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    | 168.74     | 168.74     | 168.74     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093597   | 0.093597   | 0.093597   |   0.0 |  0.06
Output  | 0.00017059 | 0.00017059 | 0.00017059 |   0.0 |  0.00
Modify  | 0.35665    | 0.35665    | 0.35665    |   0.0 |  0.21
Other   |            | 0.05988    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134620 ave      134620 max      134620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134620
Ave neighs/atom = 67.31
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.829874884901, Press = 0.0384860254649054
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -10441.254     -10441.254     -10517.887     -10517.887      296.57885      296.57885      28017.347      28017.347      1635.5041      1635.5041    
     46000  -10444.381     -10444.381     -10519.103     -10519.103      289.18194      289.18194      28045.325      28045.325     -190.1782      -190.1782     
Loop time of 168.993 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 46.943 hours/ns, 5.917 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    | 168.48     | 168.48     | 168.48     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093103   | 0.093103   | 0.093103   |   0.0 |  0.06
Output  | 0.00020656 | 0.00020656 | 0.00020656 |   0.0 |  0.00
Modify  | 0.3556     | 0.3556     | 0.3556     |   0.0 |  0.21
Other   |            | 0.05915    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135244 ave      135244 max      135244 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135244
Ave neighs/atom = 67.622
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.818772189601, Press = 1.01646926266123
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -10444.381     -10444.381     -10519.103     -10519.103      289.18194      289.18194      28045.325      28045.325     -190.1782      -190.1782     
     47000  -10448.607     -10448.607     -10521.811     -10521.811      283.30746      283.30746      28039.543      28039.543     -336.40723     -336.40723    
Loop time of 169.338 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.038 hours/ns, 5.905 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    | 168.83     | 168.83     | 168.83     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093291   | 0.093291   | 0.093291   |   0.0 |  0.06
Output  | 0.00016846 | 0.00016846 | 0.00016846 |   0.0 |  0.00
Modify  | 0.35453    | 0.35453    | 0.35453    |   0.0 |  0.21
Other   |            | 0.05941    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134768 ave      134768 max      134768 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134768
Ave neighs/atom = 67.384
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.791895016374, Press = 0.197670957084162
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -10448.607     -10448.607     -10521.811     -10521.811      283.30746      283.30746      28039.543      28039.543     -336.40723     -336.40723    
     48000  -10443.69      -10443.69      -10520.201     -10520.201      296.10462      296.10462      28031.351      28031.351      556.32534      556.32534    
Loop time of 187.428 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.461 ns/day, 52.063 hours/ns, 5.335 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.86     | 186.86     | 186.86     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10082    | 0.10082    | 0.10082    |   0.0 |  0.05
Output  | 0.00021146 | 0.00021146 | 0.00021146 |   0.0 |  0.00
Modify  | 0.40486    | 0.40486    | 0.40486    |   0.0 |  0.22
Other   |            | 0.0638     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134858 ave      134858 max      134858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134858
Ave neighs/atom = 67.429
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.745466491574, Press = 0.364980886385279
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -10443.69      -10443.69      -10520.201     -10520.201      296.10462      296.10462      28031.351      28031.351      556.32534      556.32534    
     49000  -10448.459     -10448.459     -10523.236     -10523.236      289.39291      289.39291      28049.654      28049.654     -823.2714      -823.2714     
Loop time of 197.557 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.437 ns/day, 54.877 hours/ns, 5.062 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.94     | 196.94     | 196.94     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1075     | 0.1075     | 0.1075     |   0.0 |  0.05
Output  | 0.00023665 | 0.00023665 | 0.00023665 |   0.0 |  0.00
Modify  | 0.44462    | 0.44462    | 0.44462    |   0.0 |  0.23
Other   |            | 0.06674    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135042 ave      135042 max      135042 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135042
Ave neighs/atom = 67.521
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.727788257273, Press = 0.583124757494244
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -10448.459     -10448.459     -10523.236     -10523.236      289.39291      289.39291      28049.654      28049.654     -823.2714      -823.2714     
     50000  -10444.29      -10444.29      -10519.512     -10519.512      291.11464      291.11464      28044.594      28044.594     -335.08706     -335.08706    
Loop time of 187.023 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.462 ns/day, 51.951 hours/ns, 5.347 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.46     | 186.46     | 186.46     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10048    | 0.10048    | 0.10048    |   0.0 |  0.05
Output  | 0.00016857 | 0.00016857 | 0.00016857 |   0.0 |  0.00
Modify  | 0.40352    | 0.40352    | 0.40352    |   0.0 |  0.22
Other   |            | 0.06347    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134508 ave      134508 max      134508 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134508
Ave neighs/atom = 67.254
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.71703139199, Press = -1.28990869700266
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -10444.29      -10444.29      -10519.512     -10519.512      291.11464      291.11464      28044.594      28044.594     -335.08706     -335.08706    
     51000  -10446.327     -10446.327     -10519.487     -10519.487      283.13534      283.13534      28000.336      28000.336      2213.6141      2213.6141    
Loop time of 192.414 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.449 ns/day, 53.448 hours/ns, 5.197 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.83     | 191.83     | 191.83     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10308    | 0.10308    | 0.10308    |   0.0 |  0.05
Output  | 0.00016752 | 0.00016752 | 0.00016752 |   0.0 |  0.00
Modify  | 0.41897    | 0.41897    | 0.41897    |   0.0 |  0.22
Other   |            | 0.0641     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135164 ave      135164 max      135164 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135164
Ave neighs/atom = 67.582
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.65947081145, Press = 1.09669748233004
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -10446.327     -10446.327     -10519.487     -10519.487      283.13534      283.13534      28000.336      28000.336      2213.6141      2213.6141    
     52000  -10442.639     -10442.639     -10517.43      -10517.43       289.44809      289.44809      28078.715      28078.715     -1842.0599     -1842.0599    
Loop time of 196.755 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.654 hours/ns, 5.082 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    | 196.14     | 196.14     | 196.14     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10662    | 0.10662    | 0.10662    |   0.0 |  0.05
Output  | 0.0001688  | 0.0001688  | 0.0001688  |   0.0 |  0.00
Modify  | 0.44177    | 0.44177    | 0.44177    |   0.0 |  0.22
Other   |            | 0.06654    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135296 ave      135296 max      135296 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135296
Ave neighs/atom = 67.648
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.691222106809, Press = 0.77446048847533
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -10442.639     -10442.639     -10517.43      -10517.43       289.44809      289.44809      28078.715      28078.715     -1842.0599     -1842.0599    
     53000  -10444.912     -10444.912     -10521.498     -10521.498      296.39389      296.39389      28045.968      28045.968     -343.38737     -343.38737    
Loop time of 180.41 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.479 ns/day, 50.114 hours/ns, 5.543 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    | 179.87     | 179.87     | 179.87     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097333   | 0.097333   | 0.097333   |   0.0 |  0.05
Output  | 0.00024025 | 0.00024025 | 0.00024025 |   0.0 |  0.00
Modify  | 0.38329    | 0.38329    | 0.38329    |   0.0 |  0.21
Other   |            | 0.06168    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134796 ave      134796 max      134796 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134796
Ave neighs/atom = 67.398
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.715970661336, Press = -0.477935567507665
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -10444.912     -10444.912     -10521.498     -10521.498      296.39389      296.39389      28045.968      28045.968     -343.38737     -343.38737    
     54000  -10441.303     -10441.303     -10519.386     -10519.386      302.18974      302.18974      28030.329      28030.329      853.54727      853.54727    
Loop time of 198.025 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.436 ns/day, 55.007 hours/ns, 5.050 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    | 197.41     | 197.41     | 197.41     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10621    | 0.10621    | 0.10621    |   0.0 |  0.05
Output  | 0.0001712  | 0.0001712  | 0.0001712  |   0.0 |  0.00
Modify  | 0.43839    | 0.43839    | 0.43839    |   0.0 |  0.22
Other   |            | 0.06531    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134878 ave      134878 max      134878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134878
Ave neighs/atom = 67.439
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.797894582526, Press = 0.605059126767528
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -10441.303     -10441.303     -10519.386     -10519.386      302.18974      302.18974      28030.329      28030.329      853.54727      853.54727    
     55000  -10445.692     -10445.692     -10521.651     -10521.651      293.96834      293.96834      28042.289      28042.289     -21.842083     -21.842083    
Loop time of 198.455 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.435 ns/day, 55.126 hours/ns, 5.039 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    | 197.85     | 197.85     | 197.85     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10606    | 0.10606    | 0.10606    |   0.0 |  0.05
Output  | 0.00017025 | 0.00017025 | 0.00017025 |   0.0 |  0.00
Modify  | 0.43491    | 0.43491    | 0.43491    |   0.0 |  0.22
Other   |            | 0.0654     |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135040 ave      135040 max      135040 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135040
Ave neighs/atom = 67.52
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.82189073451, Press = 0.363379809792538
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -10445.692     -10445.692     -10521.651     -10521.651      293.96834      293.96834      28042.289      28042.289     -21.842083     -21.842083    
     56000  -10443.291     -10443.291     -10517.989     -10517.989      289.08589      289.08589      28043.621      28043.621     -24.528918     -24.528918    
Loop time of 197.301 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.438 ns/day, 54.806 hours/ns, 5.068 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.69     | 196.69     | 196.69     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10561    | 0.10561    | 0.10561    |   0.0 |  0.05
Output  | 0.00016798 | 0.00016798 | 0.00016798 |   0.0 |  0.00
Modify  | 0.43614    | 0.43614    | 0.43614    |   0.0 |  0.22
Other   |            | 0.06565    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134648 ave      134648 max      134648 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134648
Ave neighs/atom = 67.324
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.851657446612, Press = 0.160453102540906
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -10443.291     -10443.291     -10517.989     -10517.989      289.08589      289.08589      28043.621      28043.621     -24.528918     -24.528918    
     57000  -10447.556     -10447.556     -10522.146     -10522.146      288.6688       288.6688       28035.48       28035.48       139.11478      139.11478    
Loop time of 197.259 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.438 ns/day, 54.794 hours/ns, 5.069 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    | 196.64     | 196.64     | 196.64     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10718    | 0.10718    | 0.10718    |   0.0 |  0.05
Output  | 0.00017134 | 0.00017134 | 0.00017134 |   0.0 |  0.00
Modify  | 0.44353    | 0.44353    | 0.44353    |   0.0 |  0.22
Other   |            | 0.06608    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135058 ave      135058 max      135058 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135058
Ave neighs/atom = 67.529
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.85358948993, Press = 0.137540031834469
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -10447.556     -10447.556     -10522.146     -10522.146      288.6688       288.6688       28035.48       28035.48       139.11478      139.11478    
     58000  -10443.838     -10443.838     -10520.736     -10520.736      297.60304      297.60304      28045.685      28045.685     -238.64433     -238.64433    
Loop time of 197.954 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.436 ns/day, 54.987 hours/ns, 5.052 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    | 197.34     | 197.34     | 197.34     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10668    | 0.10668    | 0.10668    |   0.0 |  0.05
Output  | 0.00017011 | 0.00017011 | 0.00017011 |   0.0 |  0.00
Modify  | 0.43901    | 0.43901    | 0.43901    |   0.0 |  0.22
Other   |            | 0.06628    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134632 ave      134632 max      134632 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134632
Ave neighs/atom = 67.316
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.826617816931, Press = 0.0969069724671704
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -10443.838     -10443.838     -10520.736     -10520.736      297.60304      297.60304      28045.685      28045.685     -238.64433     -238.64433    
     59000  -10443.351     -10443.351     -10520.072     -10520.072      296.91813      296.91813      28047.248      28047.248     -299.77471     -299.77471    
Loop time of 197.307 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.438 ns/day, 54.808 hours/ns, 5.068 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.69     | 196.69     | 196.69     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10689    | 0.10689    | 0.10689    |   0.0 |  0.05
Output  | 0.00021644 | 0.00021644 | 0.00021644 |   0.0 |  0.00
Modify  | 0.44402    | 0.44402    | 0.44402    |   0.0 |  0.23
Other   |            | 0.06771    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134890 ave      134890 max      134890 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134890
Ave neighs/atom = 67.445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.810763377141, Press = 0.00377066842600848
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -10443.351     -10443.351     -10520.072     -10520.072      296.91813      296.91813      28047.248      28047.248     -299.77471     -299.77471    
     60000  -10446.131     -10446.131     -10521.731     -10521.731      292.57882      292.57882      28032.744      28032.744      232.2968       232.2968     
Loop time of 197.025 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.729 hours/ns, 5.075 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.4      | 196.4      | 196.4      |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10724    | 0.10724    | 0.10724    |   0.0 |  0.05
Output  | 0.00017447 | 0.00017447 | 0.00017447 |   0.0 |  0.00
Modify  | 0.44779    | 0.44779    | 0.44779    |   0.0 |  0.23
Other   |            | 0.06718    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134944 ave      134944 max      134944 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134944
Ave neighs/atom = 67.472
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.776755775043, Press = 0.0666271208416143
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -10446.131     -10446.131     -10521.731     -10521.731      292.57882      292.57882      28032.744      28032.744      232.2968       232.2968     
     61000  -10446.56      -10446.56      -10520.868     -10520.868      287.5802       287.5802       28039.967      28039.967     -40.904354     -40.904354    
Loop time of 196.788 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.663 hours/ns, 5.082 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.17     | 196.17     | 196.17     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10786    | 0.10786    | 0.10786    |   0.0 |  0.05
Output  | 0.00021619 | 0.00021619 | 0.00021619 |   0.0 |  0.00
Modify  | 0.44531    | 0.44531    | 0.44531    |   0.0 |  0.23
Other   |            | 0.06759    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134838 ave      134838 max      134838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134838
Ave neighs/atom = 67.419
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.781634413075, Press = 0.680742153952755
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -10446.56      -10446.56      -10520.868     -10520.868      287.5802       287.5802       28039.967      28039.967     -40.904354     -40.904354    
     62000  -10444.169     -10444.169     -10519.843     -10519.843      292.8671       292.8671       28076.148      28076.148     -1917.0965     -1917.0965    
Loop time of 197.383 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.438 ns/day, 54.829 hours/ns, 5.066 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.77     | 196.77     | 196.77     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10595    | 0.10595    | 0.10595    |   0.0 |  0.05
Output  | 0.00028755 | 0.00028755 | 0.00028755 |   0.0 |  0.00
Modify  | 0.43929    | 0.43929    | 0.43929    |   0.0 |  0.22
Other   |            | 0.06678    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134780 ave      134780 max      134780 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134780
Ave neighs/atom = 67.39
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.774617680356, Press = -0.691518035744532
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -10444.169     -10444.169     -10519.843     -10519.843      292.8671       292.8671       28076.148      28076.148     -1917.0965     -1917.0965    
     63000  -10446.719     -10446.719     -10521.344     -10521.344      288.80803      288.80803      27993.749      27993.749      2383.3483      2383.3483    
Loop time of 197.299 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.438 ns/day, 54.805 hours/ns, 5.068 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.68     | 196.68     | 196.68     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10692    | 0.10692    | 0.10692    |   0.0 |  0.05
Output  | 0.00017411 | 0.00017411 | 0.00017411 |   0.0 |  0.00
Modify  | 0.44335    | 0.44335    | 0.44335    |   0.0 |  0.22
Other   |            | 0.06707    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134652 ave      134652 max      134652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134652
Ave neighs/atom = 67.326
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.799350658943, Press = -0.182137739455805
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -10446.719     -10446.719     -10521.344     -10521.344      288.80803      288.80803      27993.749      27993.749      2383.3483      2383.3483    
     64000  -10444.228     -10444.228     -10520.571     -10520.571      295.45342      295.45342      28047.947      28047.947     -479.33517     -479.33517    
Loop time of 180.73 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.478 ns/day, 50.203 hours/ns, 5.533 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    | 180.18     | 180.18     | 180.18     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09888    | 0.09888    | 0.09888    |   0.0 |  0.05
Output  | 0.00021295 | 0.00021295 | 0.00021295 |   0.0 |  0.00
Modify  | 0.38929    | 0.38929    | 0.38929    |   0.0 |  0.22
Other   |            | 0.06252    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135146 ave      135146 max      135146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135146
Ave neighs/atom = 67.573
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.796648204518, Press = 0.851872671207196
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -10444.228     -10444.228     -10520.571     -10520.571      295.45342      295.45342      28047.947      28047.947     -479.33517     -479.33517    
     65000  -10444.87      -10444.87      -10521.082     -10521.082      294.94808      294.94808      28053.483      28053.483     -778.46389     -778.46389    
Loop time of 197.032 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.731 hours/ns, 5.075 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    | 196.42     | 196.42     | 196.42     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10585    | 0.10585    | 0.10585    |   0.0 |  0.05
Output  | 0.00016988 | 0.00016988 | 0.00016988 |   0.0 |  0.00
Modify  | 0.44071    | 0.44071    | 0.44071    |   0.0 |  0.22
Other   |            | 0.06654    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134868 ave      134868 max      134868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134868
Ave neighs/atom = 67.434
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.806514379779, Press = -0.265334337306686
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -10444.87      -10444.87      -10521.082     -10521.082      294.94808      294.94808      28053.483      28053.483     -778.46389     -778.46389    
     66000  -10443.048     -10443.048     -10520.001     -10520.001      297.81654      297.81654      28038.341      28038.341      230.06579      230.06579    
Loop time of 196.846 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.680 hours/ns, 5.080 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    | 196.23     | 196.23     | 196.23     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10691    | 0.10691    | 0.10691    |   0.0 |  0.05
Output  | 0.00017053 | 0.00017053 | 0.00017053 |   0.0 |  0.00
Modify  | 0.44554    | 0.44554    | 0.44554    |   0.0 |  0.23
Other   |            | 0.06689    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134680 ave      134680 max      134680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134680
Ave neighs/atom = 67.34
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.826087012224, Press = -0.063018210596695
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -10443.048     -10443.048     -10520.001     -10520.001      297.81654      297.81654      28038.341      28038.341      230.06579      230.06579    
     67000  -10444.715     -10444.715     -10517.575     -10517.575      281.97445      281.97445      28043.821      28043.821     -1.0021001     -1.0021001    
Loop time of 197.106 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.438 ns/day, 54.752 hours/ns, 5.073 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    | 196.49     | 196.49     | 196.49     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10648    | 0.10648    | 0.10648    |   0.0 |  0.05
Output  | 0.00022655 | 0.00022655 | 0.00022655 |   0.0 |  0.00
Modify  | 0.44305    | 0.44305    | 0.44305    |   0.0 |  0.22
Other   |            | 0.06697    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135030 ave      135030 max      135030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135030
Ave neighs/atom = 67.515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.799688011512, Press = 0.0302557325893388
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -10444.715     -10444.715     -10517.575     -10517.575      281.97445      281.97445      28043.821      28043.821     -1.0021001     -1.0021001    
     68000  -10447.565     -10447.565     -10521.692     -10521.692      286.88065      286.88065      28034.745      28034.745      246.6682       246.6682     
Loop time of 197.014 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.726 hours/ns, 5.076 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.4      | 196.4      | 196.4      |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10677    | 0.10677    | 0.10677    |   0.0 |  0.05
Output  | 0.00025896 | 0.00025896 | 0.00025896 |   0.0 |  0.00
Modify  | 0.44511    | 0.44511    | 0.44511    |   0.0 |  0.23
Other   |            | 0.06718    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134980 ave      134980 max      134980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134980
Ave neighs/atom = 67.49
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.784574854665, Press = -0.279855844565817
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -10447.565     -10447.565     -10521.692     -10521.692      286.88065      286.88065      28034.745      28034.745      246.6682       246.6682     
     69000  -10443.855     -10443.855     -10518.709     -10518.709      289.68976      289.68976      28026.813      28026.813      1032.0305      1032.0305    
Loop time of 198.031 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.436 ns/day, 55.008 hours/ns, 5.050 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    | 197.43     | 197.43     | 197.43     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10501    | 0.10501    | 0.10501    |   0.0 |  0.05
Output  | 0.00048057 | 0.00048057 | 0.00048057 |   0.0 |  0.00
Modify  | 0.43072    | 0.43072    | 0.43072    |   0.0 |  0.22
Other   |            | 0.06576    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134830 ave      134830 max      134830 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134830
Ave neighs/atom = 67.415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.755550953829, Press = 0.187993070457143
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -10443.855     -10443.855     -10518.709     -10518.709      289.68976      289.68976      28026.813      28026.813      1032.0305      1032.0305    
     70000  -10445.662     -10445.662     -10521.333     -10521.333      292.85324      292.85324      28061.121      28061.121     -1075.2814     -1075.2814    
Loop time of 194.848 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.443 ns/day, 54.124 hours/ns, 5.132 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    | 194.25     | 194.25     | 194.25     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10411    | 0.10411    | 0.10411    |   0.0 |  0.05
Output  | 0.00021336 | 0.00021336 | 0.00021336 |   0.0 |  0.00
Modify  | 0.42356    | 0.42356    | 0.42356    |   0.0 |  0.22
Other   |            | 0.06586    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135182 ave      135182 max      135182 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135182
Ave neighs/atom = 67.591
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.776036987256, Press = 0.104334728447054
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -10445.662     -10445.662     -10521.333     -10521.333      292.85324      292.85324      28061.121      28061.121     -1075.2814     -1075.2814    
     71000  -10441.806     -10441.806     -10518.779     -10518.779      297.89188      297.89188      28051.5        28051.5       -354.35113     -354.35113    
Loop time of 197.038 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.438 ns/day, 54.733 hours/ns, 5.075 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.42     | 196.42     | 196.42     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10749    | 0.10749    | 0.10749    |   0.0 |  0.05
Output  | 0.00017035 | 0.00017035 | 0.00017035 |   0.0 |  0.00
Modify  | 0.44509    | 0.44509    | 0.44509    |   0.0 |  0.23
Other   |            | 0.06731    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134554 ave      134554 max      134554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134554
Ave neighs/atom = 67.277
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.817112675272, Press = -0.812324867216184
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -10441.806     -10441.806     -10518.779     -10518.779      297.89188      297.89188      28051.5        28051.5       -354.35113     -354.35113    
     72000  -10446.78      -10446.78      -10521.844     -10521.844      290.50687      290.50687      27993.369      27993.369      2398.5064      2398.5064    
Loop time of 196.734 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.648 hours/ns, 5.083 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.12     | 196.12     | 196.12     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10564    | 0.10564    | 0.10564    |   0.0 |  0.05
Output  | 0.00027442 | 0.00027442 | 0.00027442 |   0.0 |  0.00
Modify  | 0.44013    | 0.44013    | 0.44013    |   0.0 |  0.22
Other   |            | 0.06704    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134972 ave      134972 max      134972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134972
Ave neighs/atom = 67.486
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.837840077205, Press = 0.369717753794585
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -10446.78      -10446.78      -10521.844     -10521.844      290.50687      290.50687      27993.369      27993.369      2398.5064      2398.5064    
     73000  -10444.275     -10444.275     -10520.419     -10520.419      294.68511      294.68511      28082.777      28082.777     -2231.601      -2231.601     
Loop time of 174.422 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.495 ns/day, 48.451 hours/ns, 5.733 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    | 173.89     | 173.89     | 173.89     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.096643   | 0.096643   | 0.096643   |   0.0 |  0.06
Output  | 0.00016782 | 0.00016782 | 0.00016782 |   0.0 |  0.00
Modify  | 0.37253    | 0.37253    | 0.37253    |   0.0 |  0.21
Other   |            | 0.06093    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134840 ave      134840 max      134840 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134840
Ave neighs/atom = 67.42
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.837217084175, Press = 0.584377619408718
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -10444.275     -10444.275     -10520.419     -10520.419      294.68511      294.68511      28082.777      28082.777     -2231.601      -2231.601     
     74000  -10446.277     -10446.277     -10521.569     -10521.569      291.38678      291.38678      28045.513      28045.513     -366.93291     -366.93291    
Loop time of 180.874 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.478 ns/day, 50.243 hours/ns, 5.529 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    | 180.32     | 180.32     | 180.32     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099515   | 0.099515   | 0.099515   |   0.0 |  0.06
Output  | 0.00016907 | 0.00016907 | 0.00016907 |   0.0 |  0.00
Modify  | 0.39273    | 0.39273    | 0.39273    |   0.0 |  0.22
Other   |            | 0.06196    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134440 ave      134440 max      134440 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134440
Ave neighs/atom = 67.22
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.81401203714, Press = -0.633810538641752
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -10446.277     -10446.277     -10521.569     -10521.569      291.38678      291.38678      28045.513      28045.513     -366.93291     -366.93291    
     75000  -10442.879     -10442.879     -10519.465     -10519.465      296.39688      296.39688      28028.342      28028.342      952.52312      952.52312    
Loop time of 196.475 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.440 ns/day, 54.576 hours/ns, 5.090 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.85     | 195.85     | 195.85     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10822    | 0.10822    | 0.10822    |   0.0 |  0.06
Output  | 0.00023154 | 0.00023154 | 0.00023154 |   0.0 |  0.00
Modify  | 0.44823    | 0.44823    | 0.44823    |   0.0 |  0.23
Other   |            | 0.06613    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134838 ave      134838 max      134838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134838
Ave neighs/atom = 67.419
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.807703974514, Press = -0.0155598467319054
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -10442.879     -10442.879     -10519.465     -10519.465      296.39688      296.39688      28028.342      28028.342      952.52312      952.52312    
     76000  -10448.125     -10448.125     -10522.525     -10522.525      287.93672      287.93672      28047.695      28047.695     -679.83568     -679.83568    
Loop time of 196.961 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.439 ns/day, 54.711 hours/ns, 5.077 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 196.35     | 196.35     | 196.35     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10677    | 0.10677    | 0.10677    |   0.0 |  0.05
Output  | 0.00022864 | 0.00022864 | 0.00022864 |   0.0 |  0.00
Modify  | 0.4391     | 0.4391     | 0.4391     |   0.0 |  0.22
Other   |            | 0.06504    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134982 ave      134982 max      134982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134982
Ave neighs/atom = 67.491
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.781503316714, Press = 0.1450860029328
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -10448.125     -10448.125     -10522.525     -10522.525      287.93672      287.93672      28047.695      28047.695     -679.83568     -679.83568    
     77000  -10443.565     -10443.565     -10520.197     -10520.197      296.57686      296.57686      28048.974      28048.974     -448.66554     -448.66554    
Loop time of 196.445 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.440 ns/day, 54.568 hours/ns, 5.090 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 195.83     | 195.83     | 195.83     |   0.0 | 99.68
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10695    | 0.10695    | 0.10695    |   0.0 |  0.05
Output  | 0.00021227 | 0.00021227 | 0.00021227 |   0.0 |  0.00
Modify  | 0.44721    | 0.44721    | 0.44721    |   0.0 |  0.23
Other   |            | 0.06567    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134506 ave      134506 max      134506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134506
Ave neighs/atom = 67.253
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.774552761431, Press = -0.480028144951583
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -10443.565     -10443.565     -10520.197     -10520.197      296.57686      296.57686      28048.974      28048.974     -448.66554     -448.66554    
     78000  -10446.771     -10446.771     -10521.825     -10521.825      290.46801      290.46801      28008.574      28008.574      1593.7831      1593.7831    
Loop time of 194.631 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.444 ns/day, 54.064 hours/ns, 5.138 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 194.02     | 194.02     | 194.02     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10574    | 0.10574    | 0.10574    |   0.0 |  0.05
Output  | 0.00022864 | 0.00022864 | 0.00022864 |   0.0 |  0.00
Modify  | 0.438      | 0.438      | 0.438      |   0.0 |  0.23
Other   |            | 0.06668    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134844 ave      134844 max      134844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134844
Ave neighs/atom = 67.422
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.757517540316, Press = 0.0438043545222928
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -10446.771     -10446.771     -10521.825     -10521.825      290.46801      290.46801      28008.574      28008.574      1593.7831      1593.7831    
     79000  -10444.59      -10444.59      -10521.086     -10521.086      296.04724      296.04724      28063.107      28063.107     -1126.78       -1126.78      
Loop time of 180.702 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.478 ns/day, 50.195 hours/ns, 5.534 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    | 180.15     | 180.15     | 180.15     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.099119   | 0.099119   | 0.099119   |   0.0 |  0.05
Output  | 0.00016855 | 0.00016855 | 0.00016855 |   0.0 |  0.00
Modify  | 0.39115    | 0.39115    | 0.39115    |   0.0 |  0.22
Other   |            | 0.06319    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135030 ave      135030 max      135030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135030
Ave neighs/atom = 67.515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.773154297783, Press = 0.48414916264188
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -10444.59      -10444.59      -10521.086     -10521.086      296.04724      296.04724      28063.107      28063.107     -1126.78       -1126.78      
     80000  -10445.187     -10445.187     -10519.75      -10519.75       288.56599      288.56599      28055.978      28055.978     -837.49863     -837.49863    
Loop time of 169.135 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 46.982 hours/ns, 5.912 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    | 168.62     | 168.62     | 168.62     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094341   | 0.094341   | 0.094341   |   0.0 |  0.06
Output  | 0.00021074 | 0.00021074 | 0.00021074 |   0.0 |  0.00
Modify  | 0.35679    | 0.35679    | 0.35679    |   0.0 |  0.21
Other   |            | 0.06036    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134726 ave      134726 max      134726 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134726
Ave neighs/atom = 67.363
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.759601933776, Press = -0.947875442014829
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -10445.187     -10445.187     -10519.75      -10519.75       288.56599      288.56599      28055.978      28055.978     -837.49863     -837.49863    
     81000  -10446.983     -10446.983     -10522.159     -10522.159      290.94084      290.94084      28001.49       28001.49       1959.022       1959.022     
Loop time of 169.137 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 46.983 hours/ns, 5.912 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    | 168.63     | 168.63     | 168.63     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094091   | 0.094091   | 0.094091   |   0.0 |  0.06
Output  | 0.00016929 | 0.00016929 | 0.00016929 |   0.0 |  0.00
Modify  | 0.35764    | 0.35764    | 0.35764    |   0.0 |  0.21
Other   |            | 0.06009    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134732 ave      134732 max      134732 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134732
Ave neighs/atom = 67.366
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.77279502112, Press = 0.0251351055278009
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -10446.983     -10446.983     -10522.159     -10522.159      290.94084      290.94084      28001.49       28001.49       1959.022       1959.022     
     82000  -10443.981     -10443.981     -10518.545     -10518.545      288.57226      288.57226      28056.788      28056.788     -618.32901     -618.32901    
Loop time of 173.136 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.499 ns/day, 48.093 hours/ns, 5.776 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    | 172.61     | 172.61     | 172.61     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094563   | 0.094563   | 0.094563   |   0.0 |  0.05
Output  | 0.00023882 | 0.00023882 | 0.00023882 |   0.0 |  0.00
Modify  | 0.36681    | 0.36681    | 0.36681    |   0.0 |  0.21
Other   |            | 0.06026    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134930 ave      134930 max      134930 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134930
Ave neighs/atom = 67.465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.74480271265, Press = 0.170259882422016
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -10443.981     -10443.981     -10518.545     -10518.545      288.57226      288.57226      28056.788      28056.788     -618.32901     -618.32901    
     83000  -10446.093     -10446.093     -10521.346     -10521.346      291.23848      291.23848      28039.999      28039.999     -26.442459     -26.442459    
Loop time of 188.913 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.457 ns/day, 52.476 hours/ns, 5.293 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.34     | 188.34     | 188.34     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10226    | 0.10226    | 0.10226    |   0.0 |  0.05
Output  | 0.00015921 | 0.00015921 | 0.00015921 |   0.0 |  0.00
Modify  | 0.40958    | 0.40958    | 0.40958    |   0.0 |  0.22
Other   |            | 0.06523    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134828 ave      134828 max      134828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134828
Ave neighs/atom = 67.414
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.733326730013, Press = -0.365514643915847
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -10446.093     -10446.093     -10521.346     -10521.346      291.23848      291.23848      28039.999      28039.999     -26.442459     -26.442459    
     84000  -10443.876     -10443.876     -10520.39      -10520.39       296.11887      296.11887      28027.739      28027.739      662.4905       662.4905     
Loop time of 171.769 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.503 ns/day, 47.714 hours/ns, 5.822 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    | 171.25     | 171.25     | 171.25     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095855   | 0.095855   | 0.095855   |   0.0 |  0.06
Output  | 0.00016643 | 0.00016643 | 0.00016643 |   0.0 |  0.00
Modify  | 0.36603    | 0.36603    | 0.36603    |   0.0 |  0.21
Other   |            | 0.05964    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134760 ave      134760 max      134760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134760
Ave neighs/atom = 67.38
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.720531675584, Press = -0.158986475014063
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -10443.876     -10443.876     -10520.39      -10520.39       296.11887      296.11887      28027.739      28027.739      662.4905       662.4905     
     85000  -10447.411     -10447.411     -10522.515     -10522.515      290.65908      290.65908      28028.347      28028.347      565.01815      565.01815    
Loop time of 169.178 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 46.994 hours/ns, 5.911 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    | 168.66     | 168.66     | 168.66     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094573   | 0.094573   | 0.094573   |   0.0 |  0.06
Output  | 0.00016898 | 0.00016898 | 0.00016898 |   0.0 |  0.00
Modify  | 0.35996    | 0.35996    | 0.35996    |   0.0 |  0.21
Other   |            | 0.05945    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134816 ave      134816 max      134816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134816
Ave neighs/atom = 67.408
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.72304667023, Press = 0.114002895096039
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -10447.411     -10447.411     -10522.515     -10522.515      290.65908      290.65908      28028.347      28028.347      565.01815      565.01815    
     86000  -10443.333     -10443.333     -10518.173     -10518.173      289.64122      289.64122      28092.913      28092.913     -2677.8992     -2677.8992    
Loop time of 169.205 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 47.001 hours/ns, 5.910 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 168.69     | 168.69     | 168.69     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093954   | 0.093954   | 0.093954   |   0.0 |  0.06
Output  | 0.0001699  | 0.0001699  | 0.0001699  |   0.0 |  0.00
Modify  | 0.35948    | 0.35948    | 0.35948    |   0.0 |  0.21
Other   |            | 0.05944    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134746 ave      134746 max      134746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134746
Ave neighs/atom = 67.373
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.702278987213, Press = -0.140089492094772
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -10443.333     -10443.333     -10518.173     -10518.173      289.64122      289.64122      28092.913      28092.913     -2677.8992     -2677.8992    
     87000  -10446.8       -10446.8       -10522.787     -10522.787      294.07783      294.07783      28019.173      28019.173      868.77672      868.77672    
Loop time of 169.387 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.052 hours/ns, 5.904 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 168.87     | 168.87     | 168.87     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094243   | 0.094243   | 0.094243   |   0.0 |  0.06
Output  | 0.0001682  | 0.0001682  | 0.0001682  |   0.0 |  0.00
Modify  | 0.36048    | 0.36048    | 0.36048    |   0.0 |  0.21
Other   |            | 0.05973    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134652 ave      134652 max      134652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134652
Ave neighs/atom = 67.326
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.706579041416, Press = -0.813753256113192
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -10446.8       -10446.8       -10522.787     -10522.787      294.07783      294.07783      28019.173      28019.173      868.77672      868.77672    
     88000  -10443.563     -10443.563     -10519.67      -10519.67       294.54149      294.54149      28025.908      28025.908      972.97185      972.97185    
Loop time of 169.465 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.074 hours/ns, 5.901 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 168.95     | 168.95     | 168.95     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093754   | 0.093754   | 0.093754   |   0.0 |  0.06
Output  | 0.00021157 | 0.00021157 | 0.00021157 |   0.0 |  0.00
Modify  | 0.35943    | 0.35943    | 0.35943    |   0.0 |  0.21
Other   |            | 0.05914    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134828 ave      134828 max      134828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134828
Ave neighs/atom = 67.414
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.693378959967, Press = 0.337893122781448
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -10443.563     -10443.563     -10519.67      -10519.67       294.54149      294.54149      28025.908      28025.908      972.97185      972.97185    
     89000  -10444.521     -10444.521     -10519.072     -10519.072      288.52108      288.52108      28062.275      28062.275     -1031.7219     -1031.7219    
Loop time of 169.566 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.102 hours/ns, 5.897 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    | 169.05     | 169.05     | 169.05     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094277   | 0.094277   | 0.094277   |   0.0 |  0.06
Output  | 0.00016761 | 0.00016761 | 0.00016761 |   0.0 |  0.00
Modify  | 0.36057    | 0.36057    | 0.36057    |   0.0 |  0.21
Other   |            | 0.05932    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134902 ave      134902 max      134902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134902
Ave neighs/atom = 67.451
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.687984143001, Press = -0.152579973974211
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -10444.521     -10444.521     -10519.072     -10519.072      288.52108      288.52108      28062.275      28062.275     -1031.7219     -1031.7219    
     90000  -10443.997     -10443.997     -10521.193     -10521.193      298.75774      298.75774      28034.773      28034.773      305.27399      305.27399    
Loop time of 169.352 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.042 hours/ns, 5.905 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 168.84     | 168.84     | 168.84     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09445    | 0.09445    | 0.09445    |   0.0 |  0.06
Output  | 0.00021116 | 0.00021116 | 0.00021116 |   0.0 |  0.00
Modify  | 0.36017    | 0.36017    | 0.36017    |   0.0 |  0.21
Other   |            | 0.05961    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134592 ave      134592 max      134592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134592
Ave neighs/atom = 67.296
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.695713246444, Press = -0.477637564507222
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     90000  -10443.997     -10443.997     -10521.193     -10521.193      298.75774      298.75774      28034.773      28034.773      305.27399      305.27399    
     91000  -10446.953     -10446.953     -10520.186     -10520.186      283.417        283.417        28015.797      28015.797      1289.3265      1289.3265    
Loop time of 169.316 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.032 hours/ns, 5.906 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    | 168.8      | 168.8      | 168.8      |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094089   | 0.094089   | 0.094089   |   0.0 |  0.06
Output  | 0.00016785 | 0.00016785 | 0.00016785 |   0.0 |  0.00
Modify  | 0.36002    | 0.36002    | 0.36002    |   0.0 |  0.21
Other   |            | 0.05965    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134788 ave      134788 max      134788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134788
Ave neighs/atom = 67.394
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.722113961682, Press = 0.154579119339676
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     91000  -10446.953     -10446.953     -10520.186     -10520.186      283.417        283.417        28015.797      28015.797      1289.3265      1289.3265    
     92000  -10447.541     -10447.541     -10521.618     -10521.618      286.68519      286.68519      28085.615      28085.615     -2515.8978     -2515.8978    
Loop time of 169.282 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.023 hours/ns, 5.907 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    | 168.77     | 168.77     | 168.77     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095015   | 0.095015   | 0.095015   |   0.0 |  0.06
Output  | 0.00021218 | 0.00021218 | 0.00021218 |   0.0 |  0.00
Modify  | 0.3599     | 0.3599     | 0.3599     |   0.0 |  0.21
Other   |            | 0.05974    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134922 ave      134922 max      134922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134922
Ave neighs/atom = 67.461
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.721793455313, Press = 0.337340643151531
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     92000  -10447.541     -10447.541     -10521.618     -10521.618      286.68519      286.68519      28085.615      28085.615     -2515.8978     -2515.8978    
     93000  -10443.02      -10443.02      -10520.211     -10520.211      298.73852      298.73852      28056.58       28056.58      -729.81772     -729.81772    
Loop time of 169.114 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 46.976 hours/ns, 5.913 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 168.6      | 168.6      | 168.6      |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09457    | 0.09457    | 0.09457    |   0.0 |  0.06
Output  | 0.00016827 | 0.00016827 | 0.00016827 |   0.0 |  0.00
Modify  | 0.359      | 0.359      | 0.359      |   0.0 |  0.21
Other   |            | 0.06001    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134374 ave      134374 max      134374 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134374
Ave neighs/atom = 67.187
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.710036900193, Press = -0.981183981893984
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -10443.02      -10443.02      -10520.211     -10520.211      298.73852      298.73852      28056.58       28056.58      -729.81772     -729.81772    
     94000  -10447.603     -10447.603     -10522.409     -10522.409      289.50554      289.50554      28005.725      28005.725      1689.7506      1689.7506    
Loop time of 169.193 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 46.998 hours/ns, 5.910 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    | 168.68     | 168.68     | 168.68     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094344   | 0.094344   | 0.094344   |   0.0 |  0.06
Output  | 0.00016848 | 0.00016848 | 0.00016848 |   0.0 |  0.00
Modify  | 0.35809    | 0.35809    | 0.35809    |   0.0 |  0.21
Other   |            | 0.0598     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134760 ave      134760 max      134760 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134760
Ave neighs/atom = 67.38
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.704775534955, Press = 0.0114404480294158
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -10447.603     -10447.603     -10522.409     -10522.409      289.50554      289.50554      28005.725      28005.725      1689.7506      1689.7506    
     95000  -10442.791     -10442.791     -10517.436     -10517.436      288.88333      288.88333      28061.468      28061.468     -870.60694     -870.60694    
Loop time of 169.429 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.064 hours/ns, 5.902 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    | 168.92     | 168.92     | 168.92     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093993   | 0.093993   | 0.093993   |   0.0 |  0.06
Output  | 0.00021884 | 0.00021884 | 0.00021884 |   0.0 |  0.00
Modify  | 0.35822    | 0.35822    | 0.35822    |   0.0 |  0.21
Other   |            | 0.05951    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134736 ave      134736 max      134736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134736
Ave neighs/atom = 67.368
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.684837193402, Press = 0.110181467620866
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -10442.791     -10442.791     -10517.436     -10517.436      288.88333      288.88333      28061.468      28061.468     -870.60694     -870.60694    
     96000  -10445.173     -10445.173     -10519.988     -10519.988      289.54043      289.54043      28046.358      28046.358     -264.55968     -264.55968    
Loop time of 169.766 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.509 ns/day, 47.157 hours/ns, 5.890 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    | 169.25     | 169.25     | 169.25     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093799   | 0.093799   | 0.093799   |   0.0 |  0.06
Output  | 0.00016772 | 0.00016772 | 0.00016772 |   0.0 |  0.00
Modify  | 0.35887    | 0.35887    | 0.35887    |   0.0 |  0.21
Other   |            | 0.05983    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134950 ave      134950 max      134950 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134950
Ave neighs/atom = 67.475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.686816024657, Press = -0.371552418436462
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -10445.173     -10445.173     -10519.988     -10519.988      289.54043      289.54043      28046.358      28046.358     -264.55968     -264.55968    
     97000  -10441.732     -10441.732     -10517.941     -10517.941      294.93966      294.93966      28024.134      28024.134      1289.0323      1289.0323    
Loop time of 169.297 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.027 hours/ns, 5.907 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    | 168.79     | 168.79     | 168.79     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093812   | 0.093812   | 0.093812   |   0.0 |  0.06
Output  | 0.00016735 | 0.00016735 | 0.00016735 |   0.0 |  0.00
Modify  | 0.35744    | 0.35744    | 0.35744    |   0.0 |  0.21
Other   |            | 0.06014    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134710 ave      134710 max      134710 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134710
Ave neighs/atom = 67.355
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.704707717234, Press = 0.00881856666834861
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     97000  -10441.732     -10441.732     -10517.941     -10517.941      294.93966      294.93966      28024.134      28024.134      1289.0323      1289.0323    
     98000  -10445.511     -10445.511     -10520.597     -10520.597      290.59294      290.59294      28053.758      28053.758     -721.26651     -721.26651    
Loop time of 169.582 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.509 ns/day, 47.106 hours/ns, 5.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    | 169.07     | 169.07     | 169.07     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093626   | 0.093626   | 0.093626   |   0.0 |  0.06
Output  | 0.00016828 | 0.00016828 | 0.00016828 |   0.0 |  0.00
Modify  | 0.35776    | 0.35776    | 0.35776    |   0.0 |  0.21
Other   |            | 0.05957    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135130 ave      135130 max      135130 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135130
Ave neighs/atom = 67.565
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.708040931228, Press = 0.220340479179909
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -10445.511     -10445.511     -10520.597     -10520.597      290.59294      290.59294      28053.758      28053.758     -721.26651     -721.26651    
     99000  -10447.178     -10447.178     -10521.762     -10521.762      288.64862      288.64862      28062.868      28062.868     -1467.6485     -1467.6485    
Loop time of 169.482 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.078 hours/ns, 5.900 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    | 168.97     | 168.97     | 168.97     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093806   | 0.093806   | 0.093806   |   0.0 |  0.06
Output  | 0.00021561 | 0.00021561 | 0.00021561 |   0.0 |  0.00
Modify  | 0.35914    | 0.35914    | 0.35914    |   0.0 |  0.21
Other   |            | 0.05974    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134722 ave      134722 max      134722 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134722
Ave neighs/atom = 67.361
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.708846202572, Press = -0.76258235612139
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -10447.178     -10447.178     -10521.762     -10521.762      288.64862      288.64862      28062.868      28062.868     -1467.6485     -1467.6485    
    100000  -10445.534     -10445.534     -10520.709     -10520.709      290.93331      290.93331      27996.645      27996.645      2297.7205      2297.7205    
Loop time of 169.459 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.072 hours/ns, 5.901 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    | 168.95     | 168.95     | 168.95     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093673   | 0.093673   | 0.093673   |   0.0 |  0.06
Output  | 0.00047345 | 0.00047345 | 0.00047345 |   0.0 |  0.00
Modify  | 0.35886    | 0.35886    | 0.35886    |   0.0 |  0.21
Other   |            | 0.0597     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134628 ave      134628 max      134628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134628
Ave neighs/atom = 67.314
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.677963811934, Press = -0.0907513027930122
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    100000  -10445.534     -10445.534     -10520.709     -10520.709      290.93331      290.93331      27996.645      27996.645      2297.7205      2297.7205    
    101000  -10443.024     -10443.024     -10518.737     -10518.737      293.01761      293.01761      28053.473      28053.473     -546.90269     -546.90269    
Loop time of 169.833 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.509 ns/day, 47.176 hours/ns, 5.888 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    | 169.32     | 169.32     | 169.32     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094035   | 0.094035   | 0.094035   |   0.0 |  0.06
Output  | 0.00017062 | 0.00017062 | 0.00017062 |   0.0 |  0.00
Modify  | 0.35798    | 0.35798    | 0.35798    |   0.0 |  0.21
Other   |            | 0.05963    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135188 ave      135188 max      135188 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135188
Ave neighs/atom = 67.594
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.684000780181, Press = 0.367189253303821
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -10443.024     -10443.024     -10518.737     -10518.737      293.01761      293.01761      28053.473      28053.473     -546.90269     -546.90269    
    102000  -10443.5       -10443.5       -10518.606     -10518.606      290.66822      290.66822      28061.65       28061.65      -927.65689     -927.65689    
Loop time of 169.655 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.509 ns/day, 47.126 hours/ns, 5.894 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 169.14     | 169.14     | 169.14     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094334   | 0.094334   | 0.094334   |   0.0 |  0.06
Output  | 0.00016988 | 0.00016988 | 0.00016988 |   0.0 |  0.00
Modify  | 0.35808    | 0.35808    | 0.35808    |   0.0 |  0.21
Other   |            | 0.05937    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134962 ave      134962 max      134962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134962
Ave neighs/atom = 67.481
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.674119834503, Press = -0.514909091722364
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    102000  -10443.5       -10443.5       -10518.606     -10518.606      290.66822      290.66822      28061.65       28061.65      -927.65689     -927.65689    
    103000  -10441.912     -10441.912     -10519.849     -10519.849      301.62512      301.62512      28005.807      28005.807      2050.7446      2050.7446    
Loop time of 169.077 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 46.966 hours/ns, 5.914 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    | 168.57     | 168.57     | 168.57     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093722   | 0.093722   | 0.093722   |   0.0 |  0.06
Output  | 0.00016781 | 0.00016781 | 0.00016781 |   0.0 |  0.00
Modify  | 0.35716    | 0.35716    | 0.35716    |   0.0 |  0.21
Other   |            | 0.06009    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134730 ave      134730 max      134730 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134730
Ave neighs/atom = 67.365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.687022340565, Press = -0.123486463382346
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    103000  -10441.912     -10441.912     -10519.849     -10519.849      301.62512      301.62512      28005.807      28005.807      2050.7446      2050.7446    
    104000  -10448.23      -10448.23      -10521.473     -10521.473      283.4609       283.4609       28056.086      28056.086     -1008.6893     -1008.6893    
Loop time of 169.292 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.025 hours/ns, 5.907 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    | 168.78     | 168.78     | 168.78     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093754   | 0.093754   | 0.093754   |   0.0 |  0.06
Output  | 0.0001662  | 0.0001662  | 0.0001662  |   0.0 |  0.00
Modify  | 0.35718    | 0.35718    | 0.35718    |   0.0 |  0.21
Other   |            | 0.06014    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135156 ave      135156 max      135156 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135156
Ave neighs/atom = 67.578
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.680664835151, Press = 0.608210647436393
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    104000  -10448.23      -10448.23      -10521.473     -10521.473      283.4609       283.4609       28056.086      28056.086     -1008.6893     -1008.6893    
    105000  -10442.613     -10442.613     -10520.135     -10520.135      300.01832      300.01832      28097.856      28097.856     -2924.5724     -2924.5724    
Loop time of 169.574 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.104 hours/ns, 5.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    | 169.06     | 169.06     | 169.06     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094745   | 0.094745   | 0.094745   |   0.0 |  0.06
Output  | 0.00020737 | 0.00020737 | 0.00020737 |   0.0 |  0.00
Modify  | 0.35855    | 0.35855    | 0.35855    |   0.0 |  0.21
Other   |            | 0.06019    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134554 ave      134554 max      134554 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134554
Ave neighs/atom = 67.277
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.665198979815, Press = -0.808450913201651
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    105000  -10442.613     -10442.613     -10520.135     -10520.135      300.01832      300.01832      28097.856      28097.856     -2924.5724     -2924.5724    
    106000  -10444.933     -10444.933     -10520.525     -10520.525      292.55033      292.55033      28011.49       28011.49       1678.7424      1678.7424    
Loop time of 169.251 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.014 hours/ns, 5.908 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    | 168.74     | 168.74     | 168.74     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094816   | 0.094816   | 0.094816   |   0.0 |  0.06
Output  | 0.0001674  | 0.0001674  | 0.0001674  |   0.0 |  0.00
Modify  | 0.35977    | 0.35977    | 0.35977    |   0.0 |  0.21
Other   |            | 0.05994    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134542 ave      134542 max      134542 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134542
Ave neighs/atom = 67.271
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.675079904467, Press = -0.176813932285255
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    106000  -10444.933     -10444.933     -10520.525     -10520.525      292.55033      292.55033      28011.49       28011.49       1678.7424      1678.7424    
    107000  -10441.406     -10441.406     -10518.754     -10518.754      299.34582      299.34582      28049.429      28049.429     -205.95433     -205.95433    
Loop time of 169.267 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.018 hours/ns, 5.908 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    | 168.76     | 168.76     | 168.76     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093679   | 0.093679   | 0.093679   |   0.0 |  0.06
Output  | 0.00016831 | 0.00016831 | 0.00016831 |   0.0 |  0.00
Modify  | 0.35696    | 0.35696    | 0.35696    |   0.0 |  0.21
Other   |            | 0.05953    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135098 ave      135098 max      135098 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135098
Ave neighs/atom = 67.549
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.701629298139, Press = 0.136649351034383
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    107000  -10441.406     -10441.406     -10518.754     -10518.754      299.34582      299.34582      28049.429      28049.429     -205.95433     -205.95433    
    108000  -10446.279     -10446.279     -10521.093     -10521.093      289.53445      289.53445      28046.945      28046.945     -535.05083     -535.05083    
Loop time of 169.286 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.024 hours/ns, 5.907 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    | 168.77     | 168.77     | 168.77     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093647   | 0.093647   | 0.093647   |   0.0 |  0.06
Output  | 0.0001688  | 0.0001688  | 0.0001688  |   0.0 |  0.00
Modify  | 0.35851    | 0.35851    | 0.35851    |   0.0 |  0.21
Other   |            | 0.05956    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134880 ave      134880 max      134880 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134880
Ave neighs/atom = 67.44
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.716342292575, Press = -0.341684461962542
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    108000  -10446.279     -10446.279     -10521.093     -10521.093      289.53445      289.53445      28046.945      28046.945     -535.05083     -535.05083    
    109000  -10446.941     -10446.941     -10520.934     -10520.934      286.36141      286.36141      28003.379      28003.379      1891.8983      1891.8983    
Loop time of 169.218 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 47.005 hours/ns, 5.910 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    | 168.71     | 168.71     | 168.71     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093587   | 0.093587   | 0.093587   |   0.0 |  0.06
Output  | 0.00016926 | 0.00016926 | 0.00016926 |   0.0 |  0.00
Modify  | 0.35874    | 0.35874    | 0.35874    |   0.0 |  0.21
Other   |            | 0.06021    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134766 ave      134766 max      134766 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134766
Ave neighs/atom = 67.383
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.726354353207, Press = 0.0369678586337528
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    109000  -10446.941     -10446.941     -10520.934     -10520.934      286.36141      286.36141      28003.379      28003.379      1891.8983      1891.8983    
    110000  -10445.487     -10445.487     -10521.633     -10521.633      294.69053      294.69053      28075.071      28075.071     -1891.5168     -1891.5168    
Loop time of 169.56 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.100 hours/ns, 5.898 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    | 169.05     | 169.05     | 169.05     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094031   | 0.094031   | 0.094031   |   0.0 |  0.06
Output  | 0.00016956 | 0.00016956 | 0.00016956 |   0.0 |  0.00
Modify  | 0.35862    | 0.35862    | 0.35862    |   0.0 |  0.21
Other   |            | 0.05932    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135146 ave      135146 max      135146 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135146
Ave neighs/atom = 67.573
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.704735801906, Press = 0.433956399423236
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    110000  -10445.487     -10445.487     -10521.633     -10521.633      294.69053      294.69053      28075.071      28075.071     -1891.5168     -1891.5168    
    111000  -10443.976     -10443.976     -10520.574     -10520.574      296.4433       296.4433       28056.775      28056.775     -1009.2676     -1009.2676    
Loop time of 169.017 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 46.949 hours/ns, 5.917 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    | 168.51     | 168.51     | 168.51     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093817   | 0.093817   | 0.093817   |   0.0 |  0.06
Output  | 0.00016835 | 0.00016835 | 0.00016835 |   0.0 |  0.00
Modify  | 0.3579     | 0.3579     | 0.3579     |   0.0 |  0.21
Other   |            | 0.05951    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134532 ave      134532 max      134532 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134532
Ave neighs/atom = 67.266
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.703396166549, Press = -0.631322409580152
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    111000  -10443.976     -10443.976     -10520.574     -10520.574      296.4433       296.4433       28056.775      28056.775     -1009.2676     -1009.2676    
    112000  -10444.794     -10444.794     -10520.839     -10520.839      294.30236      294.30236      28012.292      28012.292      1472.1793      1472.1793    
Loop time of 169.44 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.067 hours/ns, 5.902 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    | 168.93     | 168.93     | 168.93     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093857   | 0.093857   | 0.093857   |   0.0 |  0.06
Output  | 0.00016747 | 0.00016747 | 0.00016747 |   0.0 |  0.00
Modify  | 0.35923    | 0.35923    | 0.35923    |   0.0 |  0.21
Other   |            | 0.05969    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134734 ave      134734 max      134734 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134734
Ave neighs/atom = 67.367
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.705070207502, Press = -0.013284467711726
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    112000  -10444.794     -10444.794     -10520.839     -10520.839      294.30236      294.30236      28012.292      28012.292      1472.1793      1472.1793    
    113000  -10440.981     -10440.981     -10518.814     -10518.814      301.22524      301.22524      28058.808      28058.808     -896.6849      -896.6849     
Loop time of 174.326 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.496 ns/day, 48.424 hours/ns, 5.736 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    | 173.79     | 173.79     | 173.79     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.097098   | 0.097098   | 0.097098   |   0.0 |  0.06
Output  | 0.00024587 | 0.00024587 | 0.00024587 |   0.0 |  0.00
Modify  | 0.37519    | 0.37519    | 0.37519    |   0.0 |  0.22
Other   |            | 0.06146    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135046 ave      135046 max      135046 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135046
Ave neighs/atom = 67.523
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.730246564198, Press = 0.0566791496516128
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    113000  -10440.981     -10440.981     -10518.814     -10518.814      301.22524      301.22524      28058.808      28058.808     -896.6849      -896.6849     
    114000  -10444.891     -10444.891     -10519.232     -10519.232      287.70497      287.70497      28044.271      28044.271     -268.99315     -268.99315    
Loop time of 185.006 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.467 ns/day, 51.391 hours/ns, 5.405 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 184.44     | 184.44     | 184.44     |   0.0 | 99.69
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.10175    | 0.10175    | 0.10175    |   0.0 |  0.06
Output  | 0.00016785 | 0.00016785 | 0.00016785 |   0.0 |  0.00
Modify  | 0.40266    | 0.40266    | 0.40266    |   0.0 |  0.22
Other   |            | 0.06355    |            |       |  0.03

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134968 ave      134968 max      134968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134968
Ave neighs/atom = 67.484
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.732760264049, Press = -0.243064265979502
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    114000  -10444.891     -10444.891     -10519.232     -10519.232      287.70497      287.70497      28044.271      28044.271     -268.99315     -268.99315    
    115000  -10444.784     -10444.784     -10520.135     -10520.135      291.6148       291.6148       28026.914      28026.914      815.44894      815.44894    
Loop time of 169.144 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 46.985 hours/ns, 5.912 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    | 168.63     | 168.63     | 168.63     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093673   | 0.093673   | 0.093673   |   0.0 |  0.06
Output  | 0.00016822 | 0.00016822 | 0.00016822 |   0.0 |  0.00
Modify  | 0.35853    | 0.35853    | 0.35853    |   0.0 |  0.21
Other   |            | 0.06007    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135118 ave      135118 max      135118 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135118
Ave neighs/atom = 67.559
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.752561005025, Press = -0.107701739829409
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    115000  -10444.784     -10444.784     -10520.135     -10520.135      291.6148       291.6148       28026.914      28026.914      815.44894      815.44894    
    116000  -10446.07      -10446.07      -10521.093     -10521.093      290.34779      290.34779      28049.299      28049.299     -511.3897      -511.3897     
Loop time of 169.391 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.053 hours/ns, 5.904 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    | 168.88     | 168.88     | 168.88     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093512   | 0.093512   | 0.093512   |   0.0 |  0.06
Output  | 0.00016905 | 0.00016905 | 0.00016905 |   0.0 |  0.00
Modify  | 0.35786    | 0.35786    | 0.35786    |   0.0 |  0.21
Other   |            | 0.05957    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134816 ave      134816 max      134816 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134816
Ave neighs/atom = 67.408
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.750370203534, Press = -0.0136926317295519
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    116000  -10446.07      -10446.07      -10521.093     -10521.093      290.34779      290.34779      28049.299      28049.299     -511.3897      -511.3897     
    117000  -10443.459     -10443.459     -10519.19      -10519.19       293.08746      293.08746      28040.494      28040.494      23.079066      23.079066    
Loop time of 169.565 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.101 hours/ns, 5.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    | 169.06     | 169.06     | 169.06     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093384   | 0.093384   | 0.093384   |   0.0 |  0.06
Output  | 0.00016743 | 0.00016743 | 0.00016743 |   0.0 |  0.00
Modify  | 0.3562     | 0.3562     | 0.3562     |   0.0 |  0.21
Other   |            | 0.05954    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134724 ave      134724 max      134724 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134724
Ave neighs/atom = 67.362
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.754555665614, Press = -0.609785976682305
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    117000  -10443.459     -10443.459     -10519.19      -10519.19       293.08746      293.08746      28040.494      28040.494      23.079066      23.079066    
    118000  -10443.494     -10443.494     -10519.723     -10519.723      295.01494      295.01494      28003.294      28003.294      2149.8242      2149.8242    
Loop time of 169.554 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.098 hours/ns, 5.898 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    | 169.04     | 169.04     | 169.04     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093795   | 0.093795   | 0.093795   |   0.0 |  0.06
Output  | 0.00016834 | 0.00016834 | 0.00016834 |   0.0 |  0.00
Modify  | 0.35725    | 0.35725    | 0.35725    |   0.0 |  0.21
Other   |            | 0.05967    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134954 ave      134954 max      134954 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134954
Ave neighs/atom = 67.477
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.740219914508, Press = 0.273681471322072
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    118000  -10443.494     -10443.494     -10519.723     -10519.723      295.01494      295.01494      28003.294      28003.294      2149.8242      2149.8242    
    119000  -10447.35      -10447.35      -10522.59      -10522.59       291.18534      291.18534      28078.419      28078.419     -2255.5214     -2255.5214    
Loop time of 169.725 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.509 ns/day, 47.146 hours/ns, 5.892 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    | 169.21     | 169.21     | 169.21     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094532   | 0.094532   | 0.094532   |   0.0 |  0.06
Output  | 0.00015944 | 0.00015944 | 0.00015944 |   0.0 |  0.00
Modify  | 0.35778    | 0.35778    | 0.35778    |   0.0 |  0.21
Other   |            | 0.05985    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135068 ave      135068 max      135068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135068
Ave neighs/atom = 67.534
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.738877231422, Press = 0.0322856742989006
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    119000  -10447.35      -10447.35      -10522.59      -10522.59       291.18534      291.18534      28078.419      28078.419     -2255.5214     -2255.5214    
    120000  -10443.683     -10443.683     -10519.323     -10519.323      292.73794      292.73794      28036.519      28036.519      389.56349      389.56349    
Loop time of 171.799 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.503 ns/day, 47.722 hours/ns, 5.821 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    | 171.28     | 171.28     | 171.28     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095106   | 0.095106   | 0.095106   |   0.0 |  0.06
Output  | 0.00016848 | 0.00016848 | 0.00016848 |   0.0 |  0.00
Modify  | 0.36284    | 0.36284    | 0.36284    |   0.0 |  0.21
Other   |            | 0.06028    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134446 ave      134446 max      134446 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134446
Ave neighs/atom = 67.223
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.743098043083, Press = -0.434163772824773
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    120000  -10443.683     -10443.683     -10519.323     -10519.323      292.73794      292.73794      28036.519      28036.519      389.56349      389.56349    
    121000  -10444.31      -10444.31      -10520.008     -10520.008      292.96002      292.96002      28029.129      28029.129      763.19665      763.19665    
Loop time of 169.455 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.071 hours/ns, 5.901 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    | 168.94     | 168.94     | 168.94     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093762   | 0.093762   | 0.093762   |   0.0 |  0.06
Output  | 0.00016895 | 0.00016895 | 0.00016895 |   0.0 |  0.00
Modify  | 0.35782    | 0.35782    | 0.35782    |   0.0 |  0.21
Other   |            | 0.0599     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134926 ave      134926 max      134926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134926
Ave neighs/atom = 67.463
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.757010815777, Press = 0.00152448994971248
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    121000  -10444.31      -10444.31      -10520.008     -10520.008      292.96002      292.96002      28029.129      28029.129      763.19665      763.19665    
    122000  -10445.874     -10445.874     -10521.541     -10521.541      292.83671      292.83671      28040.41       28040.41      -194.98315     -194.98315    
Loop time of 169.411 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.059 hours/ns, 5.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    | 168.9      | 168.9      | 168.9      |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093096   | 0.093096   | 0.093096   |   0.0 |  0.05
Output  | 0.00016947 | 0.00016947 | 0.00016947 |   0.0 |  0.00
Modify  | 0.35819    | 0.35819    | 0.35819    |   0.0 |  0.21
Other   |            | 0.06082    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134832 ave      134832 max      134832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134832
Ave neighs/atom = 67.416
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.780383725868, Press = -0.112387566017671
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    122000  -10445.874     -10445.874     -10521.541     -10521.541      292.83671      292.83671      28040.41       28040.41      -194.98315     -194.98315    
    123000  -10440.293     -10440.293     -10517.026     -10517.026      296.96269      296.96269      28046.225      28046.225     -4.6327994     -4.6327994    
Loop time of 169.359 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.044 hours/ns, 5.905 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    | 168.85     | 168.85     | 168.85     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.092956   | 0.092956   | 0.092956   |   0.0 |  0.05
Output  | 0.00016493 | 0.00016493 | 0.00016493 |   0.0 |  0.00
Modify  | 0.35767    | 0.35767    | 0.35767    |   0.0 |  0.21
Other   |            | 0.06075    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134802 ave      134802 max      134802 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134802
Ave neighs/atom = 67.401
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.791620437978, Press = -0.236454966275399
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    123000  -10440.293     -10440.293     -10517.026     -10517.026      296.96269      296.96269      28046.225      28046.225     -4.6327994     -4.6327994    
    124000  -10445.132     -10445.132     -10520.716     -10520.716      292.51761      292.51761      28008.316      28008.316      1565.255       1565.255     
Loop time of 168.791 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.512 ns/day, 46.886 hours/ns, 5.924 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    | 168.28     | 168.28     | 168.28     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093966   | 0.093966   | 0.093966   |   0.0 |  0.06
Output  | 0.00016977 | 0.00016977 | 0.00016977 |   0.0 |  0.00
Modify  | 0.35789    | 0.35789    | 0.35789    |   0.0 |  0.21
Other   |            | 0.06042    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135054 ave      135054 max      135054 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135054
Ave neighs/atom = 67.527
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.810929188315, Press = 0.0433188387642817
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    124000  -10445.132     -10445.132     -10520.716     -10520.716      292.51761      292.51761      28008.316      28008.316      1565.255       1565.255     
    125000  -10438.379     -10438.379     -10517.052     -10517.052      304.47519      304.47519      28082.173      28082.173     -1927.8561     -1927.8561    
Loop time of 169.248 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.013 hours/ns, 5.908 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    | 168.74     | 168.74     | 168.74     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093933   | 0.093933   | 0.093933   |   0.0 |  0.06
Output  | 0.0001691  | 0.0001691  | 0.0001691  |   0.0 |  0.00
Modify  | 0.35752    | 0.35752    | 0.35752    |   0.0 |  0.21
Other   |            | 0.05967    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135198 ave      135198 max      135198 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135198
Ave neighs/atom = 67.599
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.828295280445, Press = 0.11274616695935
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    125000  -10438.379     -10438.379     -10517.052     -10517.052      304.47519      304.47519      28082.173      28082.173     -1927.8561     -1927.8561    
    126000  -10446.116     -10446.116     -10520.988     -10520.988      289.76404      289.76404      28041.775      28041.775     -215.47133     -215.47133    
Loop time of 168.881 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.512 ns/day, 46.912 hours/ns, 5.921 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    | 168.37     | 168.37     | 168.37     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093456   | 0.093456   | 0.093456   |   0.0 |  0.06
Output  | 0.00016789 | 0.00016789 | 0.00016789 |   0.0 |  0.00
Modify  | 0.3559     | 0.3559     | 0.3559     |   0.0 |  0.21
Other   |            | 0.06       |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134896 ave      134896 max      134896 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134896
Ave neighs/atom = 67.448
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.838337154152, Press = -0.687788904691075
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    126000  -10446.116     -10446.116     -10520.988     -10520.988      289.76404      289.76404      28041.775      28041.775     -215.47133     -215.47133    
    127000  -10443.988     -10443.988     -10521.044     -10521.044      298.21736      298.21736      28003.42       28003.42       1976.2877      1976.2877    
Loop time of 168.956 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 46.932 hours/ns, 5.919 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    | 168.44     | 168.44     | 168.44     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093391   | 0.093391   | 0.093391   |   0.0 |  0.06
Output  | 0.00016869 | 0.00016869 | 0.00016869 |   0.0 |  0.00
Modify  | 0.35783    | 0.35783    | 0.35783    |   0.0 |  0.21
Other   |            | 0.06012    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134792 ave      134792 max      134792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134792
Ave neighs/atom = 67.396
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.844104714898, Press = 0.108439849347349
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    127000  -10443.988     -10443.988     -10521.044     -10521.044      298.21736      298.21736      28003.42       28003.42       1976.2877      1976.2877    
    128000  -10440.193     -10440.193     -10516.472     -10516.472      295.20837      295.20837      28070.268      28070.268     -1190.6352     -1190.6352    
Loop time of 169.17 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 46.992 hours/ns, 5.911 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    | 168.66     | 168.66     | 168.66     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093389   | 0.093389   | 0.093389   |   0.0 |  0.06
Output  | 0.0001676  | 0.0001676  | 0.0001676  |   0.0 |  0.00
Modify  | 0.35657    | 0.35657    | 0.35657    |   0.0 |  0.21
Other   |            | 0.06067    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135076 ave      135076 max      135076 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135076
Ave neighs/atom = 67.538
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.859885598848, Press = 0.0308154060551764
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    128000  -10440.193     -10440.193     -10516.472     -10516.472      295.20837      295.20837      28070.268      28070.268     -1190.6352     -1190.6352    
    129000  -10446.656     -10446.656     -10521.683     -10521.683      290.35884      290.35884      28033.308      28033.308      349.90471      349.90471    
Loop time of 169.33 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.036 hours/ns, 5.906 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    | 168.82     | 168.82     | 168.82     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09423    | 0.09423    | 0.09423    |   0.0 |  0.06
Output  | 0.00016919 | 0.00016919 | 0.00016919 |   0.0 |  0.00
Modify  | 0.35784    | 0.35784    | 0.35784    |   0.0 |  0.21
Other   |            | 0.0602     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134934 ave      134934 max      134934 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134934
Ave neighs/atom = 67.467
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.878955652126, Press = -0.327628640863794
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    129000  -10446.656     -10446.656     -10521.683     -10521.683      290.35884      290.35884      28033.308      28033.308      349.90471      349.90471    
    130000  -10447.413     -10447.413     -10520.988     -10520.988      284.73972      284.73972      28021.754      28021.754      852.60255      852.60255    
Loop time of 169.306 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.029 hours/ns, 5.906 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    | 168.79     | 168.79     | 168.79     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094837   | 0.094837   | 0.094837   |   0.0 |  0.06
Output  | 0.00017172 | 0.00017172 | 0.00017172 |   0.0 |  0.00
Modify  | 0.35671    | 0.35671    | 0.35671    |   0.0 |  0.21
Other   |            | 0.05992    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134706 ave      134706 max      134706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134706
Ave neighs/atom = 67.353
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.870164260175, Press = -0.0120304728634973
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    130000  -10447.413     -10447.413     -10520.988     -10520.988      284.73972      284.73972      28021.754      28021.754      852.60255      852.60255    
    131000  -10445.933     -10445.933     -10522.069     -10522.069      294.65531      294.65531      28056.918      28056.918     -1112.8258     -1112.8258    
Loop time of 169.217 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 47.005 hours/ns, 5.910 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    | 168.7      | 168.7      | 168.7      |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09442    | 0.09442    | 0.09442    |   0.0 |  0.06
Output  | 0.00016844 | 0.00016844 | 0.00016844 |   0.0 |  0.00
Modify  | 0.35695    | 0.35695    | 0.35695    |   0.0 |  0.21
Other   |            | 0.06039    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134962 ave      134962 max      134962 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134962
Ave neighs/atom = 67.481
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.874737862073, Press = -0.124032074723317
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    131000  -10445.933     -10445.933     -10522.069     -10522.069      294.65531      294.65531      28056.918      28056.918     -1112.8258     -1112.8258    
    132000  -10440.749     -10440.749     -10520.704     -10520.704      309.43576      309.43576      28026.268      28026.268      981.2224       981.2224     
Loop time of 169.095 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 46.971 hours/ns, 5.914 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    | 168.58     | 168.58     | 168.58     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093435   | 0.093435   | 0.093435   |   0.0 |  0.06
Output  | 0.00016721 | 0.00016721 | 0.00016721 |   0.0 |  0.00
Modify  | 0.35801    | 0.35801    | 0.35801    |   0.0 |  0.21
Other   |            | 0.06026    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134666 ave      134666 max      134666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134666
Ave neighs/atom = 67.333
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.893916322414, Press = -0.649916882444264
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    132000  -10440.749     -10440.749     -10520.704     -10520.704      309.43576      309.43576      28026.268      28026.268      981.2224       981.2224     
    133000  -10444.635     -10444.635     -10521.001     -10521.001      295.54542      295.54542      28011.527      28011.527      1550.8108      1550.8108    
Loop time of 169.393 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.054 hours/ns, 5.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    | 168.88     | 168.88     | 168.88     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093327   | 0.093327   | 0.093327   |   0.0 |  0.06
Output  | 0.00016945 | 0.00016945 | 0.00016945 |   0.0 |  0.00
Modify  | 0.35821    | 0.35821    | 0.35821    |   0.0 |  0.21
Other   |            | 0.06006    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134862 ave      134862 max      134862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134862
Ave neighs/atom = 67.431
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.900361630881, Press = 0.587807957406047
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    133000  -10444.635     -10444.635     -10521.001     -10521.001      295.54542      295.54542      28011.527      28011.527      1550.8108      1550.8108    
    134000  -10443.927     -10443.927     -10520.894     -10520.894      297.87163      297.87163      28083.944      28083.944     -2311.8265     -2311.8265    
Loop time of 169.402 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.056 hours/ns, 5.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    | 168.89     | 168.89     | 168.89     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093295   | 0.093295   | 0.093295   |   0.0 |  0.06
Output  | 0.00016814 | 0.00016814 | 0.00016814 |   0.0 |  0.00
Modify  | 0.35806    | 0.35806    | 0.35806    |   0.0 |  0.21
Other   |            | 0.05998    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134916 ave      134916 max      134916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134916
Ave neighs/atom = 67.458
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.91519667379, Press = -0.209793161731948
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    134000  -10443.927     -10443.927     -10520.894     -10520.894      297.87163      297.87163      28083.944      28083.944     -2311.8265     -2311.8265    
    135000  -10440.508     -10440.508     -10517.387     -10517.387      297.52966      297.52966      28027.985      28027.985      1183.7863      1183.7863    
Loop time of 168.801 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.512 ns/day, 46.889 hours/ns, 5.924 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    | 168.29     | 168.29     | 168.29     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093849   | 0.093849   | 0.093849   |   0.0 |  0.06
Output  | 0.00016858 | 0.00016858 | 0.00016858 |   0.0 |  0.00
Modify  | 0.35655    | 0.35655    | 0.35655    |   0.0 |  0.21
Other   |            | 0.06064    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134418 ave      134418 max      134418 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134418
Ave neighs/atom = 67.209
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.918379209825, Press = -0.33321107901521
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    135000  -10440.508     -10440.508     -10517.387     -10517.387      297.52966      297.52966      28027.985      28027.985      1183.7863      1183.7863    
    136000  -10445.39      -10445.39      -10520.649     -10520.649      291.26048      291.26048      28029.135      28029.135      692.81357      692.81357    
Loop time of 169.359 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.044 hours/ns, 5.905 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    | 168.85     | 168.85     | 168.85     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093491   | 0.093491   | 0.093491   |   0.0 |  0.06
Output  | 0.00017008 | 0.00017008 | 0.00017008 |   0.0 |  0.00
Modify  | 0.35792    | 0.35792    | 0.35792    |   0.0 |  0.21
Other   |            | 0.06084    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135150 ave      135150 max      135150 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135150
Ave neighs/atom = 67.575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.935611636495, Press = 0.160014907528645
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    136000  -10445.39      -10445.39      -10520.649     -10520.649      291.26048      291.26048      28029.135      28029.135      692.81357      692.81357    
    137000  -10444.834     -10444.834     -10520.532     -10520.532      292.95713      292.95713      28080.843      28080.843     -2259.8121     -2259.8121    
Loop time of 169.605 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.509 ns/day, 47.113 hours/ns, 5.896 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    | 169.09     | 169.09     | 169.09     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093764   | 0.093764   | 0.093764   |   0.0 |  0.06
Output  | 0.00016855 | 0.00016855 | 0.00016855 |   0.0 |  0.00
Modify  | 0.35703    | 0.35703    | 0.35703    |   0.0 |  0.21
Other   |            | 0.06047    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135018 ave      135018 max      135018 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135018
Ave neighs/atom = 67.509
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.949763679278, Press = -0.2005894841077
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    137000  -10444.834     -10444.834     -10520.532     -10520.532      292.95713      292.95713      28080.843      28080.843     -2259.8121     -2259.8121    
    138000  -10444.869     -10444.869     -10521.819     -10521.819      297.80324      297.80324      28001.547      28001.547      2010.0235      2010.0235    
Loop time of 169.404 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.057 hours/ns, 5.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    | 168.89     | 168.89     | 168.89     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093244   | 0.093244   | 0.093244   |   0.0 |  0.06
Output  | 0.0001682  | 0.0001682  | 0.0001682  |   0.0 |  0.00
Modify  | 0.35816    | 0.35816    | 0.35816    |   0.0 |  0.21
Other   |            | 0.06057    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134456 ave      134456 max      134456 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134456
Ave neighs/atom = 67.228
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.940470022937, Press = -0.886328729803692
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    138000  -10444.869     -10444.869     -10521.819     -10521.819      297.80324      297.80324      28001.547      28001.547      2010.0235      2010.0235    
    139000  -10445.23      -10445.23      -10521.581     -10521.581      295.48746      295.48746      28007.703      28007.703      1706.6901      1706.6901    
Loop time of 169.561 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.100 hours/ns, 5.898 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    | 169.05     | 169.05     | 169.05     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093348   | 0.093348   | 0.093348   |   0.0 |  0.06
Output  | 0.00016877 | 0.00016877 | 0.00016877 |   0.0 |  0.00
Modify  | 0.35741    | 0.35741    | 0.35741    |   0.0 |  0.21
Other   |            | 0.06012    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135060 ave      135060 max      135060 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135060
Ave neighs/atom = 67.53
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.941723772379, Press = 0.341506701786356
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    139000  -10445.23      -10445.23      -10521.581     -10521.581      295.48746      295.48746      28007.703      28007.703      1706.6901      1706.6901    
    140000  -10445.29      -10445.29      -10519.584     -10519.584      287.52457      287.52457      28073.256      28073.256     -1722.3753     -1722.3753    
Loop time of 169.668 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.509 ns/day, 47.130 hours/ns, 5.894 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 169.16     | 169.16     | 169.16     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093775   | 0.093775   | 0.093775   |   0.0 |  0.06
Output  | 0.00016723 | 0.00016723 | 0.00016723 |   0.0 |  0.00
Modify  | 0.35744    | 0.35744    | 0.35744    |   0.0 |  0.21
Other   |            | 0.06049    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135074 ave      135074 max      135074 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135074
Ave neighs/atom = 67.537
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.924926218697, Press = 0.0435045115656134
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    140000  -10445.29      -10445.29      -10519.584     -10519.584      287.52457      287.52457      28073.256      28073.256     -1722.3753     -1722.3753    
    141000  -10442.852     -10442.852     -10519.887     -10519.887      298.13408      298.13408      28043.331      28043.331     -108.31077     -108.31077    
Loop time of 169.307 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.030 hours/ns, 5.906 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    | 168.79     | 168.79     | 168.79     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093711   | 0.093711   | 0.093711   |   0.0 |  0.06
Output  | 0.00016704 | 0.00016704 | 0.00016704 |   0.0 |  0.00
Modify  | 0.35787    | 0.35787    | 0.35787    |   0.0 |  0.21
Other   |            | 0.0601     |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134502 ave      134502 max      134502 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134502
Ave neighs/atom = 67.251
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.932874473941, Press = -0.379785703746625
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    141000  -10442.852     -10442.852     -10519.887     -10519.887      298.13408      298.13408      28043.331      28043.331     -108.31077     -108.31077    
    142000  -10446.804     -10446.804     -10524.552     -10524.552      300.89294      300.89294      28014.615      28014.615      1065.162       1065.162     
Loop time of 169.705 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.509 ns/day, 47.140 hours/ns, 5.893 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    | 169.19     | 169.19     | 169.19     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09371    | 0.09371    | 0.09371    |   0.0 |  0.06
Output  | 0.00016805 | 0.00016805 | 0.00016805 |   0.0 |  0.00
Modify  | 0.35657    | 0.35657    | 0.35657    |   0.0 |  0.21
Other   |            | 0.06027    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134958 ave      134958 max      134958 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134958
Ave neighs/atom = 67.479
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.928122196936, Press = 0.134215602451742
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    142000  -10446.804     -10446.804     -10524.552     -10524.552      300.89294      300.89294      28014.615      28014.615      1065.162       1065.162     
    143000  -10443.958     -10443.958     -10520.391     -10520.391      295.80408      295.80408      28091.548      28091.548     -2762.6343     -2762.6343    
Loop time of 169.649 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.509 ns/day, 47.125 hours/ns, 5.895 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    | 169.14     | 169.14     | 169.14     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.09378    | 0.09378    | 0.09378    |   0.0 |  0.06
Output  | 0.00016932 | 0.00016932 | 0.00016932 |   0.0 |  0.00
Modify  | 0.3564     | 0.3564     | 0.3564     |   0.0 |  0.21
Other   |            | 0.06035    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134712 ave      134712 max      134712 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134712
Ave neighs/atom = 67.356
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.926170743854, Press = 0.10901022666855
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    143000  -10443.958     -10443.958     -10520.391     -10520.391      295.80408      295.80408      28091.548      28091.548     -2762.6343     -2762.6343    
    144000  -10447.481     -10447.481     -10520.745     -10520.745      283.54067      283.54067      28037.134      28037.134      126.86543      126.86543    
Loop time of 169.327 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.035 hours/ns, 5.906 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    | 168.81     | 168.81     | 168.81     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.095056   | 0.095056   | 0.095056   |   0.0 |  0.06
Output  | 0.00016903 | 0.00016903 | 0.00016903 |   0.0 |  0.00
Modify  | 0.35703    | 0.35703    | 0.35703    |   0.0 |  0.21
Other   |            | 0.06055    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134414 ave      134414 max      134414 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134414
Ave neighs/atom = 67.207
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.912211963867, Press = -0.764739190042602
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    144000  -10447.481     -10447.481     -10520.745     -10520.745      283.54067      283.54067      28037.134      28037.134      126.86543      126.86543    
    145000  -10444.833     -10444.833     -10520.106     -10520.106      291.31278      291.31278      28013.575      28013.575      1683.9084      1683.9084    
Loop time of 169.47 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.075 hours/ns, 5.901 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    | 168.96     | 168.96     | 168.96     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.094419   | 0.094419   | 0.094419   |   0.0 |  0.06
Output  | 0.00016949 | 0.00016949 | 0.00016949 |   0.0 |  0.00
Modify  | 0.35767    | 0.35767    | 0.35767    |   0.0 |  0.21
Other   |            | 0.05966    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134862 ave      134862 max      134862 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134862
Ave neighs/atom = 67.431
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.921385600354, Press = 0.139072494245139
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    145000  -10444.833     -10444.833     -10520.106     -10520.106      291.31278      291.31278      28013.575      28013.575      1683.9084      1683.9084    
    146000  -10446.855     -10446.855     -10521.206     -10521.206      287.74549      287.74549      28058.379      28058.379     -971.87887     -971.87887    
Loop time of 169.491 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.510 ns/day, 47.081 hours/ns, 5.900 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    | 168.98     | 168.98     | 168.98     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093531   | 0.093531   | 0.093531   |   0.0 |  0.06
Output  | 0.00016826 | 0.00016826 | 0.00016826 |   0.0 |  0.00
Modify  | 0.35669    | 0.35669    | 0.35669    |   0.0 |  0.21
Other   |            | 0.06093    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134968 ave      134968 max      134968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134968
Ave neighs/atom = 67.484
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.942647806066, Press = 0.0626370040331776
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    146000  -10446.855     -10446.855     -10521.206     -10521.206      287.74549      287.74549      28058.379      28058.379     -971.87887     -971.87887    
    147000  -10444.023     -10444.023     -10518.467     -10518.467      288.10845      288.10845      28044.052      28044.052      156.63363      156.63363    
Loop time of 168.982 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 46.940 hours/ns, 5.918 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    | 168.47     | 168.47     | 168.47     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093987   | 0.093987   | 0.093987   |   0.0 |  0.06
Output  | 0.0001677  | 0.0001677  | 0.0001677  |   0.0 |  0.00
Modify  | 0.35725    | 0.35725    | 0.35725    |   0.0 |  0.21
Other   |            | 0.06012    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       134444 ave      134444 max      134444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 134444
Ave neighs/atom = 67.222
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.948368114569, Press = -0.356042774583884
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 10 10 10
  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) = 3.755 | 3.755 | 3.755 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    147000  -10444.023     -10444.023     -10518.467     -10518.467      288.10845      288.10845      28044.052      28044.052      156.63363      156.63363    
    148000  -10445.27      -10445.27      -10521.656     -10521.656      295.62399      295.62399      28007.41       28007.41       1749.5846      1749.5846    
Loop time of 169.243 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.511 ns/day, 47.012 hours/ns, 5.909 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    | 168.73     | 168.73     | 168.73     |   0.0 | 99.70
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.093485   | 0.093485   | 0.093485   |   0.0 |  0.06
Output  | 0.00016673 | 0.00016673 | 0.00016673 |   0.0 |  0.00
Modify  | 0.35706    | 0.35706    | 0.35706    |   0.0 |  0.21
Other   |            | 0.06006    |            |       |  0.04

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           4119 ave        4119 max        4119 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       135030 ave      135030 max      135030 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 135030
Ave neighs/atom = 67.515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T293.15.out"  else  "print 'not_converged'  file output/vol_T293.15.out"
print '${V}'  file output/vol_T293.15.out
28041.0190829827

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0