# 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.031088918447495*${_u_distance}
variable latticeconst_converted equal 3.031088918447495*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.03108891844749
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.003 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_LeeBaskesKim_2001_V__MO_868364924829_001
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.1295338222    
variable      V0_metal equal ${V0}/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 27848.1295338222/(${_u_distance}*${_u_distance}*${_u_distance})
variable      V0_metal equal 27848.1295338222/(1*${_u_distance}*${_u_distance})
variable      V0_metal equal 27848.1295338222/(1*1*${_u_distance})
variable      V0_metal equal 27848.1295338222/(1*1*1)
variable      V0_metal_times1000 equal ${V0_metal}*1000
variable      V0_metal_times1000 equal 27848.1295338222*1000

print "Initial system volume: ${V0_metal} Angstroms^3"
Initial system volume: 27848.1295338222 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_868364924829_001#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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 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.13       27848.13       2905.2857      2905.2857    
      1000  -10441.975     -10441.975     -10524.377     -10524.377      318.90485      318.90485      28071.737      28071.737     -1736.8514     -1736.8514    
Loop time of 93.8314 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.921 ns/day, 26.064 hours/ns, 10.657 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 93.367     | 93.367     | 93.367     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0734     | 0.0734     | 0.0734     |   0.0 |  0.08
Output  | 0.00021488 | 0.00021488 | 0.00021488 |   0.0 |  0.00
Modify  | 0.33524    | 0.33524    | 0.33524    |   0.0 |  0.36
Other   |            | 0.05532    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       116000 ave      116000 max      116000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 116000
Ave neighs/atom = 58
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -10441.975     -10441.975     -10524.377     -10524.377      318.90485      318.90485      28071.737      28071.737     -1736.8514     -1736.8514    
      2000  -10445.48      -10445.48      -10522.453     -10522.453      297.89289      297.89289      28055.011      28055.011     -782.62051     -782.62051    
Loop time of 96.6712 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.853 hours/ns, 10.344 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.208     | 96.208     | 96.208     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073052   | 0.073052   | 0.073052   |   0.0 |  0.08
Output  | 0.00023587 | 0.00023587 | 0.00023587 |   0.0 |  0.00
Modify  | 0.33477    | 0.33477    | 0.33477    |   0.0 |  0.35
Other   |            | 0.05532    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115976 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -10445.48      -10445.48      -10522.453     -10522.453      297.89289      297.89289      28055.011      28055.011     -782.62051     -782.62051    
      3000  -10444.971     -10444.971     -10520.311     -10520.311      291.57716      291.57716      28009.258      28009.258      1873.5289      1873.5289    
Loop time of 96.7007 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.861 hours/ns, 10.341 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.238     | 96.238     | 96.238     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073191   | 0.073191   | 0.073191   |   0.0 |  0.08
Output  | 0.00024222 | 0.00024222 | 0.00024222 |   0.0 |  0.00
Modify  | 0.33412    | 0.33412    | 0.33412    |   0.0 |  0.35
Other   |            | 0.05499    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115972 ave      115972 max      115972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115972
Ave neighs/atom = 57.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -10444.971     -10444.971     -10520.311     -10520.311      291.57716      291.57716      28009.258      28009.258      1873.5289      1873.5289    
      4000  -10444.629     -10444.629     -10517.29      -10517.29       281.20652      281.20652      28040.482      28040.482      207.95074      207.95074    
Loop time of 96.3823 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.773 hours/ns, 10.375 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.92      | 95.92      | 95.92      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073307   | 0.073307   | 0.073307   |   0.0 |  0.08
Output  | 0.00020943 | 0.00020943 | 0.00020943 |   0.0 |  0.00
Modify  | 0.33427    | 0.33427    | 0.33427    |   0.0 |  0.35
Other   |            | 0.05497    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115982 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -10444.629     -10444.629     -10517.29      -10517.29       281.20652      281.20652      28040.482      28040.482      207.95074      207.95074    
      5000  -10443.818     -10443.818     -10520.889     -10520.889      298.27108      298.27108      28083.28       28083.28      -1995.0173     -1995.0173    
Loop time of 96.7027 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.862 hours/ns, 10.341 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.237     | 96.237     | 96.237     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073054   | 0.073054   | 0.073054   |   0.0 |  0.08
Output  | 0.00016974 | 0.00016974 | 0.00016974 |   0.0 |  0.00
Modify  | 0.33679    | 0.33679    | 0.33679    |   0.0 |  0.35
Other   |            | 0.0554     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 295.225707378095, Press = -263.984134683333
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -10443.818     -10443.818     -10520.889     -10520.889      298.27108      298.27108      28083.28       28083.28      -1995.0173     -1995.0173    
      6000  -10443.606     -10443.606     -10519.753     -10519.753      294.69654      294.69654      27977.763      27977.763      3614.8195      3614.8195    
Loop time of 96.8237 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.892 ns/day, 26.895 hours/ns, 10.328 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.34      | 96.34      | 96.34      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.0732     | 0.0732     | 0.0732     |   0.0 |  0.08
Output  | 0.00020815 | 0.00020815 | 0.00020815 |   0.0 |  0.00
Modify  | 0.35546    | 0.35546    | 0.35546    |   0.0 |  0.37
Other   |            | 0.05482    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115980 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.65280093777, Press = -15.5008692928491
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -10443.606     -10443.606     -10519.753     -10519.753      294.69654      294.69654      27977.763      27977.763      3614.8195      3614.8195    
      7000  -10445.146     -10445.146     -10519.389     -10519.389      287.32636      287.32636      28043.468      28043.468     -113.98132     -113.98132    
Loop time of 96.6492 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.847 hours/ns, 10.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    | 96.164     | 96.164     | 96.164     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073197   | 0.073197   | 0.073197   |   0.0 |  0.08
Output  | 0.00017108 | 0.00017108 | 0.00017108 |   0.0 |  0.00
Modify  | 0.35656    | 0.35656    | 0.35656    |   0.0 |  0.37
Other   |            | 0.05494    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115980 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.845735770497, Press = 34.5487036760294
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -10445.146     -10445.146     -10519.389     -10519.389      287.32636      287.32636      28043.468      28043.468     -113.98132     -113.98132    
      8000  -10444.2       -10444.2       -10519.861     -10519.861      292.81595      292.81595      28062.276      28062.276     -1083.8128     -1083.8128    
Loop time of 96.5056 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.807 hours/ns, 10.362 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.02      | 96.02      | 96.02      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073778   | 0.073778   | 0.073778   |   0.0 |  0.08
Output  | 0.00016788 | 0.00016788 | 0.00016788 |   0.0 |  0.00
Modify  | 0.35635    | 0.35635    | 0.35635    |   0.0 |  0.37
Other   |            | 0.05501    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115968 ave      115968 max      115968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115968
Ave neighs/atom = 57.984
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.494239966109, Press = -1.99468144166268
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -10444.2       -10444.2       -10519.861     -10519.861      292.81595      292.81595      28062.276      28062.276     -1083.8128     -1083.8128    
      9000  -10443.852     -10443.852     -10518.231     -10518.231      287.85433      287.85433      28011.474      28011.474      1602.285       1602.285     
Loop time of 96.6925 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.859 hours/ns, 10.342 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.208     | 96.208     | 96.208     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073151   | 0.073151   | 0.073151   |   0.0 |  0.08
Output  | 0.00016983 | 0.00016983 | 0.00016983 |   0.0 |  0.00
Modify  | 0.35601    | 0.35601    | 0.35601    |   0.0 |  0.37
Other   |            | 0.05499    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115970 ave      115970 max      115970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115970
Ave neighs/atom = 57.985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.038110442141, Press = 4.6048911886614
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -10443.852     -10443.852     -10518.231     -10518.231      287.85433      287.85433      28011.474      28011.474      1602.285       1602.285     
     10000  -10444.111     -10444.111     -10518.913     -10518.913      289.49272      289.49272      28049.631      28049.631     -489.35991     -489.35991    
Loop time of 96.7793 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.883 hours/ns, 10.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    | 96.295     | 96.295     | 96.295     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073646   | 0.073646   | 0.073646   |   0.0 |  0.08
Output  | 0.00017    | 0.00017    | 0.00017    |   0.0 |  0.00
Modify  | 0.35549    | 0.35549    | 0.35549    |   0.0 |  0.37
Other   |            | 0.05497    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115988 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.550915198074, Press = 13.568819258197
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -10444.111     -10444.111     -10518.913     -10518.913      289.49272      289.49272      28049.631      28049.631     -489.35991     -489.35991    
     11000  -10444.965     -10444.965     -10522.43      -10522.43       299.79653      299.79653      28088.758      28088.758     -2685.1504     -2685.1504    
Loop time of 96.7036 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.862 hours/ns, 10.341 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    | 96.219     | 96.219     | 96.219     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073234   | 0.073234   | 0.073234   |   0.0 |  0.08
Output  | 0.00016963 | 0.00016963 | 0.00016963 |   0.0 |  0.00
Modify  | 0.35613    | 0.35613    | 0.35613    |   0.0 |  0.37
Other   |            | 0.05516    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115976 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.634748512166, Press = -10.4785980277251
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -10444.965     -10444.965     -10522.43      -10522.43       299.79653      299.79653      28088.758      28088.758     -2685.1504     -2685.1504    
     12000  -10441.982     -10441.982     -10520.562     -10520.562      304.10974      304.10974      27987.443      27987.443      2937.9691      2937.9691    
Loop time of 96.7784 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.883 hours/ns, 10.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    | 96.293     | 96.293     | 96.293     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073312   | 0.073312   | 0.073312   |   0.0 |  0.08
Output  | 0.00017098 | 0.00017098 | 0.00017098 |   0.0 |  0.00
Modify  | 0.35649    | 0.35649    | 0.35649    |   0.0 |  0.37
Other   |            | 0.05516    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115976 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.636903211219, Press = 2.04924704253579
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -10441.982     -10441.982     -10520.562     -10520.562      304.10974      304.10974      27987.443      27987.443      2937.9691      2937.9691    
     13000  -10446.568     -10446.568     -10520.527     -10520.527      286.22865      286.22865      28048.463      28048.463     -303.73171     -303.73171    
Loop time of 96.731 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.870 hours/ns, 10.338 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.246     | 96.246     | 96.246     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074107   | 0.074107   | 0.074107   |   0.0 |  0.08
Output  | 0.00017308 | 0.00017308 | 0.00017308 |   0.0 |  0.00
Modify  | 0.35595    | 0.35595    | 0.35595    |   0.0 |  0.37
Other   |            | 0.05515    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115982 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.740562659411, Press = 7.76229659534185
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -10446.568     -10446.568     -10520.527     -10520.527      286.22865      286.22865      28048.463      28048.463     -303.73171     -303.73171    
     14000  -10443.418     -10443.418     -10521.413     -10521.413      301.85173      301.85173      28061.655      28061.655     -998.31644     -998.31644    
Loop time of 96.7507 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.875 hours/ns, 10.336 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.266     | 96.266     | 96.266     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072994   | 0.072994   | 0.072994   |   0.0 |  0.08
Output  | 0.00016847 | 0.00016847 | 0.00016847 |   0.0 |  0.00
Modify  | 0.35632    | 0.35632    | 0.35632    |   0.0 |  0.37
Other   |            | 0.05483    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115984 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.00845472209, Press = 0.686111154195141
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -10443.418     -10443.418     -10521.413     -10521.413      301.85173      301.85173      28061.655      28061.655     -998.31644     -998.31644    
     15000  -10446.691     -10446.691     -10521.744     -10521.744      290.46198      290.46198      28013.605      28013.605      1392.8497      1392.8497    
Loop time of 96.8834 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.892 ns/day, 26.912 hours/ns, 10.322 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.398     | 96.398     | 96.398     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073457   | 0.073457   | 0.073457   |   0.0 |  0.08
Output  | 0.00016831 | 0.00016831 | 0.00016831 |   0.0 |  0.00
Modify  | 0.35604    | 0.35604    | 0.35604    |   0.0 |  0.37
Other   |            | 0.05539    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115972 ave      115972 max      115972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115972
Ave neighs/atom = 57.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.182029373516, Press = 2.47212160492062
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -10446.691     -10446.691     -10521.744     -10521.744      290.46198      290.46198      28013.605      28013.605      1392.8497      1392.8497    
     16000  -10442.112     -10442.112     -10520.706     -10520.706      304.16848      304.16848      28059.381      28059.381     -802.31309     -802.31309    
Loop time of 96.5496 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.819 hours/ns, 10.357 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    | 96.065     | 96.065     | 96.065     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07314    | 0.07314    | 0.07314    |   0.0 |  0.08
Output  | 0.00017023 | 0.00017023 | 0.00017023 |   0.0 |  0.00
Modify  | 0.35615    | 0.35615    | 0.35615    |   0.0 |  0.37
Other   |            | 0.0549     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115976 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.333869249123, Press = 7.98397566144144
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -10442.112     -10442.112     -10520.706     -10520.706      304.16848      304.16848      28059.381      28059.381     -802.31309     -802.31309    
     17000  -10445.753     -10445.753     -10521.047     -10521.047      291.39732      291.39732      28085.296      28085.296     -2520.0441     -2520.0441    
Loop time of 96.6025 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.834 hours/ns, 10.352 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.119     | 96.119     | 96.119     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07348    | 0.07348    | 0.07348    |   0.0 |  0.08
Output  | 0.00016982 | 0.00016982 | 0.00016982 |   0.0 |  0.00
Modify  | 0.35513    | 0.35513    | 0.35513    |   0.0 |  0.37
Other   |            | 0.05491    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115976 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.38748440897, Press = -3.09088591802411
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -10445.753     -10445.753     -10521.047     -10521.047      291.39732      291.39732      28085.296      28085.296     -2520.0441     -2520.0441    
     18000  -10443.579     -10443.579     -10518.666     -10518.666      290.59349      290.59349      27996.029      27996.029      2508.3495      2508.3495    
Loop time of 96.9261 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.891 ns/day, 26.924 hours/ns, 10.317 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.441     | 96.441     | 96.441     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07416    | 0.07416    | 0.07416    |   0.0 |  0.08
Output  | 0.00016803 | 0.00016803 | 0.00016803 |   0.0 |  0.00
Modify  | 0.35623    | 0.35623    | 0.35623    |   0.0 |  0.37
Other   |            | 0.05485    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115980 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.255719866135, Press = 1.00805663737494
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -10443.579     -10443.579     -10518.666     -10518.666      290.59349      290.59349      27996.029      27996.029      2508.3495      2508.3495    
     19000  -10446.563     -10446.563     -10521.544     -10521.544      290.18469      290.18469      28045.223      28045.223     -368.80924     -368.80924    
Loop time of 96.8977 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.892 ns/day, 26.916 hours/ns, 10.320 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.412     | 96.412     | 96.412     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073669   | 0.073669   | 0.073669   |   0.0 |  0.08
Output  | 0.00016898 | 0.00016898 | 0.00016898 |   0.0 |  0.00
Modify  | 0.35625    | 0.35625    | 0.35625    |   0.0 |  0.37
Other   |            | 0.05517    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115980 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.1002164009, Press = 5.91334231146402
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -10446.563     -10446.563     -10521.544     -10521.544      290.18469      290.18469      28045.223      28045.223     -368.80924     -368.80924    
     20000  -10444.015     -10444.015     -10520.206     -10520.206      294.86656      294.86656      28072.303      28072.303     -1738.8549     -1738.8549    
Loop time of 96.7025 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.862 hours/ns, 10.341 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    | 96.217     | 96.217     | 96.217     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073201   | 0.073201   | 0.073201   |   0.0 |  0.08
Output  | 0.00017032 | 0.00017032 | 0.00017032 |   0.0 |  0.00
Modify  | 0.35674    | 0.35674    | 0.35674    |   0.0 |  0.37
Other   |            | 0.05504    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115986 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.070844220163, Press = 0.37824699743457
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -10444.015     -10444.015     -10520.206     -10520.206      294.86656      294.86656      28072.303      28072.303     -1738.8549     -1738.8549    
     21000  -10446.557     -10446.557     -10520.039     -10520.039      284.38125      284.38125      28008.709      28008.709      1663.1192      1663.1192    
Loop time of 96.4389 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.789 hours/ns, 10.369 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.955     | 95.955     | 95.955     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073184   | 0.073184   | 0.073184   |   0.0 |  0.08
Output  | 0.00020726 | 0.00020726 | 0.00020726 |   0.0 |  0.00
Modify  | 0.35549    | 0.35549    | 0.35549    |   0.0 |  0.37
Other   |            | 0.05499    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115978 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.915293490525, Press = 1.15023638833917
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -10446.557     -10446.557     -10520.039     -10520.039      284.38125      284.38125      28008.709      28008.709      1663.1192      1663.1192    
     22000  -10445.419     -10445.419     -10521.337     -10521.337      293.80953      293.80953      28051.229      28051.229     -679.71061     -679.71061    
Loop time of 97.4248 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.887 ns/day, 27.062 hours/ns, 10.264 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.938     | 96.938     | 96.938     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074294   | 0.074294   | 0.074294   |   0.0 |  0.08
Output  | 0.0001699  | 0.0001699  | 0.0001699  |   0.0 |  0.00
Modify  | 0.35721    | 0.35721    | 0.35721    |   0.0 |  0.37
Other   |            | 0.05515    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115972 ave      115972 max      115972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115972
Ave neighs/atom = 57.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.870059914988, Press = 4.96006545864049
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -10445.419     -10445.419     -10521.337     -10521.337      293.80953      293.80953      28051.229      28051.229     -679.71061     -679.71061    
     23000  -10444.215     -10444.215     -10519.48      -10519.48       291.28167      291.28167      28092.57       28092.57      -2747.8748     -2747.8748    
Loop time of 97.5373 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.886 ns/day, 27.094 hours/ns, 10.252 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    | 97.05      | 97.05      | 97.05      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074221   | 0.074221   | 0.074221   |   0.0 |  0.08
Output  | 0.00016908 | 0.00016908 | 0.00016908 |   0.0 |  0.00
Modify  | 0.35871    | 0.35871    | 0.35871    |   0.0 |  0.37
Other   |            | 0.05461    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115978 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.855566539757, Press = -2.52808988065257
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -10444.215     -10444.215     -10519.48      -10519.48       291.28167      291.28167      28092.57       28092.57      -2747.8748     -2747.8748    
     24000  -10448.807     -10448.807     -10522.522     -10522.522      285.28687      285.28687      27993.269      27993.269      2325.3093      2325.3093    
Loop time of 97.3877 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.887 ns/day, 27.052 hours/ns, 10.268 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.902     | 96.902     | 96.902     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074195   | 0.074195   | 0.074195   |   0.0 |  0.08
Output  | 0.00016789 | 0.00016789 | 0.00016789 |   0.0 |  0.00
Modify  | 0.35686    | 0.35686    | 0.35686    |   0.0 |  0.37
Other   |            | 0.05486    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115970 ave      115970 max      115970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115970
Ave neighs/atom = 57.985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.801219516151, Press = 1.35004211192202
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -10448.807     -10448.807     -10522.522     -10522.522      285.28687      285.28687      27993.269      27993.269      2325.3093      2325.3093    
     25000  -10444.873     -10444.873     -10521.712     -10521.712      297.37287      297.37287      28047.772      28047.772     -548.16338     -548.16338    
Loop time of 106.646 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.810 ns/day, 29.624 hours/ns, 9.377 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 106.1      | 106.1      | 106.1      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079494   | 0.079494   | 0.079494   |   0.0 |  0.07
Output  | 0.00017153 | 0.00017153 | 0.00017153 |   0.0 |  0.00
Modify  | 0.40836    | 0.40836    | 0.40836    |   0.0 |  0.38
Other   |            | 0.06049    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115982 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.742818387826, Press = 3.58034743252121
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -10444.873     -10444.873     -10521.712     -10521.712      297.37287      297.37287      28047.772      28047.772     -548.16338     -548.16338    
     26000  -10446.441     -10446.441     -10521.139     -10521.139      289.08935      289.08935      28058.8        28058.8       -1113.3891     -1113.3891    
Loop time of 113.375 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.493 hours/ns, 8.820 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    | 112.78     | 112.78     | 112.78     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084587   | 0.084587   | 0.084587   |   0.0 |  0.07
Output  | 0.00017067 | 0.00017067 | 0.00017067 |   0.0 |  0.00
Modify  | 0.44781    | 0.44781    | 0.44781    |   0.0 |  0.39
Other   |            | 0.06341    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.847955784021, Press = 0.119142916815577
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -10446.441     -10446.441     -10521.139     -10521.139      289.08935      289.08935      28058.8        28058.8       -1113.3891     -1113.3891    
     27000  -10443.269     -10443.269     -10520.556     -10520.556      299.10592      299.10592      28007.393      28007.393      1819.0263      1819.0263    
Loop time of 113.634 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.565 hours/ns, 8.800 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    | 113.04     | 113.04     | 113.04     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085292   | 0.085292   | 0.085292   |   0.0 |  0.08
Output  | 0.00020412 | 0.00020412 | 0.00020412 |   0.0 |  0.00
Modify  | 0.44902    | 0.44902    | 0.44902    |   0.0 |  0.40
Other   |            | 0.06383    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115986 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.815840953337, Press = 1.13225082663181
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -10443.269     -10443.269     -10520.556     -10520.556      299.10592      299.10592      28007.393      28007.393      1819.0263      1819.0263    
     28000  -10446.344     -10446.344     -10522.025     -10522.025      292.89505      292.89505      28060.234      28060.234     -1295.3952     -1295.3952    
Loop time of 107.438 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.804 ns/day, 29.844 hours/ns, 9.308 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    | 106.88     | 106.88     | 106.88     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082323   | 0.082323   | 0.082323   |   0.0 |  0.08
Output  | 0.0002174  | 0.0002174  | 0.0002174  |   0.0 |  0.00
Modify  | 0.41322    | 0.41322    | 0.41322    |   0.0 |  0.38
Other   |            | 0.06004    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115974 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.745980624366, Press = 5.47143851019867
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -10446.344     -10446.344     -10522.025     -10522.025      292.89505      292.89505      28060.234      28060.234     -1295.3952     -1295.3952    
     29000  -10444.154     -10444.154     -10521.366     -10521.366      298.81869      298.81869      28092.641      28092.641     -2961.8738     -2961.8738    
Loop time of 113.155 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.432 hours/ns, 8.837 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    | 112.57     | 112.57     | 112.57     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083433   | 0.083433   | 0.083433   |   0.0 |  0.07
Output  | 0.00021855 | 0.00021855 | 0.00021855 |   0.0 |  0.00
Modify  | 0.43882    | 0.43882    | 0.43882    |   0.0 |  0.39
Other   |            | 0.06287    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115980 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.778842982058, Press = -1.56518292159915
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -10444.154     -10444.154     -10521.366     -10521.366      298.81869      298.81869      28092.641      28092.641     -2961.8738     -2961.8738    
     30000  -10448.062     -10448.062     -10522.824     -10522.824      289.33538      289.33538      27997.45       27997.45       2006.1924      2006.1924    
Loop time of 102.313 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.844 ns/day, 28.420 hours/ns, 9.774 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    | 101.79     | 101.79     | 101.79     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076724   | 0.076724   | 0.076724   |   0.0 |  0.07
Output  | 0.0001701  | 0.0001701  | 0.0001701  |   0.0 |  0.00
Modify  | 0.38443    | 0.38443    | 0.38443    |   0.0 |  0.38
Other   |            | 0.05795    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115980 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.676415882904, Press = 1.48586176041155
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -10448.062     -10448.062     -10522.824     -10522.824      289.33538      289.33538      27997.45       27997.45       2006.1924      2006.1924    
     31000  -10444.204     -10444.204     -10523.119     -10523.119      305.40767      305.40767      28048.683      28048.683     -542.26399     -542.26399    
Loop time of 96.1785 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.716 hours/ns, 10.397 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.693     | 95.693     | 95.693     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073949   | 0.073949   | 0.073949   |   0.0 |  0.08
Output  | 0.00016998 | 0.00016998 | 0.00016998 |   0.0 |  0.00
Modify  | 0.35578    | 0.35578    | 0.35578    |   0.0 |  0.37
Other   |            | 0.05513    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115982 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.683931441625, Press = 3.04139585415665
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -10444.204     -10444.204     -10523.119     -10523.119      305.40767      305.40767      28048.683      28048.683     -542.26399     -542.26399    
     32000  -10442.363     -10442.363     -10518.111     -10518.111      293.15484      293.15484      28068.469      28068.469     -1269.4815     -1269.4815    
Loop time of 96.8623 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.892 ns/day, 26.906 hours/ns, 10.324 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    | 96.374     | 96.374     | 96.374     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073173   | 0.073173   | 0.073173   |   0.0 |  0.08
Output  | 0.00017109 | 0.00017109 | 0.00017109 |   0.0 |  0.00
Modify  | 0.35751    | 0.35751    | 0.35751    |   0.0 |  0.37
Other   |            | 0.05696    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115984 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.653363093456, Press = 0.389376464467867
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -10442.363     -10442.363     -10518.111     -10518.111      293.15484      293.15484      28068.469      28068.469     -1269.4815     -1269.4815    
     33000  -10443.8       -10443.8       -10521.85      -10521.85       302.06341      302.06341      28016.067      28016.067      1199.8154      1199.8154    
Loop time of 99.1007 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.872 ns/day, 27.528 hours/ns, 10.091 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    | 98.598     | 98.598     | 98.598     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074708   | 0.074708   | 0.074708   |   0.0 |  0.08
Output  | 0.00020217 | 0.00020217 | 0.00020217 |   0.0 |  0.00
Modify  | 0.37011    | 0.37011    | 0.37011    |   0.0 |  0.37
Other   |            | 0.05733    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115986 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.616678268202, Press = 1.03737534754319
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -10443.8       -10443.8       -10521.85      -10521.85       302.06341      302.06341      28016.067      28016.067      1199.8154      1199.8154    
     34000  -10444.29      -10444.29      -10520.108     -10520.108      293.42257      293.42257      28041.523      28041.523     -28.753778     -28.753778    
Loop time of 101.038 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.855 ns/day, 28.066 hours/ns, 9.897 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    | 100.52     | 100.52     | 100.52     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075824   | 0.075824   | 0.075824   |   0.0 |  0.08
Output  | 0.0001714  | 0.0001714  | 0.0001714  |   0.0 |  0.00
Modify  | 0.37955    | 0.37955    | 0.37955    |   0.0 |  0.38
Other   |            | 0.05798    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115984 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.573642832876, Press = 3.00704235100327
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -10444.29      -10444.29      -10520.108     -10520.108      293.42257      293.42257      28041.523      28041.523     -28.753778     -28.753778    
     35000  -10447.182     -10447.182     -10519.897     -10519.897      281.41458      281.41458      28079.694      28079.694     -2204.0387     -2204.0387    
Loop time of 109.353 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.376 hours/ns, 9.145 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    | 108.79     | 108.79     | 108.79     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081468   | 0.081468   | 0.081468   |   0.0 |  0.07
Output  | 0.0002158  | 0.0002158  | 0.0002158  |   0.0 |  0.00
Modify  | 0.42319    | 0.42319    | 0.42319    |   0.0 |  0.39
Other   |            | 0.06089    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115972 ave      115972 max      115972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115972
Ave neighs/atom = 57.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.57316389532, Press = -0.158697386216487
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -10447.182     -10447.182     -10519.897     -10519.897      281.41458      281.41458      28079.694      28079.694     -2204.0387     -2204.0387    
     36000  -10442.845     -10442.845     -10519.048     -10519.048      294.91407      294.91407      27983.524      27983.524      3284.6451      3284.6451    
Loop time of 111.452 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.775 ns/day, 30.959 hours/ns, 8.972 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.87     | 110.87     | 110.87     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082791   | 0.082791   | 0.082791   |   0.0 |  0.07
Output  | 0.00021709 | 0.00021709 | 0.00021709 |   0.0 |  0.00
Modify  | 0.43595    | 0.43595    | 0.43595    |   0.0 |  0.39
Other   |            | 0.062      |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115980 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.554800639207, Press = 0.235875013945884
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -10442.845     -10442.845     -10519.048     -10519.048      294.91407      294.91407      27983.524      27983.524      3284.6451      3284.6451    
     37000  -10443.307     -10443.307     -10519.476     -10519.476      294.78245      294.78245      28041.93       28041.93       150.27306      150.27306    
Loop time of 113.356 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.762 ns/day, 31.488 hours/ns, 8.822 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    | 112.77     | 112.77     | 112.77     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08376    | 0.08376    | 0.08376    |   0.0 |  0.07
Output  | 0.00020291 | 0.00020291 | 0.00020291 |   0.0 |  0.00
Modify  | 0.44257    | 0.44257    | 0.44257    |   0.0 |  0.39
Other   |            | 0.06285    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115982 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.568897504132, Press = 2.92356358986349
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -10443.307     -10443.307     -10519.476     -10519.476      294.78245      294.78245      28041.93       28041.93       150.27306      150.27306    
     38000  -10443.855     -10443.855     -10519.886     -10519.886      294.24981      294.24981      28060.111      28060.111     -1070.9201     -1070.9201    
Loop time of 110.717 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.780 ns/day, 30.755 hours/ns, 9.032 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.14     | 110.14     | 110.14     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081904   | 0.081904   | 0.081904   |   0.0 |  0.07
Output  | 0.00023369 | 0.00023369 | 0.00023369 |   0.0 |  0.00
Modify  | 0.43024    | 0.43024    | 0.43024    |   0.0 |  0.39
Other   |            | 0.06324    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115976 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.695871400551, Press = 0.737110351996709
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -10443.855     -10443.855     -10519.886     -10519.886      294.24981      294.24981      28060.111      28060.111     -1070.9201     -1070.9201    
     39000  -10443.842     -10443.842     -10519.17      -10519.17       291.52691      291.52691      28018.385      28018.385      1342.3177      1342.3177    
Loop time of 105.828 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.397 hours/ns, 9.449 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 105.28     | 105.28     | 105.28     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079419   | 0.079419   | 0.079419   |   0.0 |  0.08
Output  | 0.00021435 | 0.00021435 | 0.00021435 |   0.0 |  0.00
Modify  | 0.40506    | 0.40506    | 0.40506    |   0.0 |  0.38
Other   |            | 0.06027    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115988 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.740805561779, Press = 1.20412190695115
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -10443.842     -10443.842     -10519.17      -10519.17       291.52691      291.52691      28018.385      28018.385      1342.3177      1342.3177    
     40000  -10446.263     -10446.263     -10520.988     -10520.988      289.19554      289.19554      28047.494      28047.494     -552.37785     -552.37785    
Loop time of 113.021 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.395 hours/ns, 8.848 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    | 112.43     | 112.43     | 112.43     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084678   | 0.084678   | 0.084678   |   0.0 |  0.07
Output  | 0.00021716 | 0.00021716 | 0.00021716 |   0.0 |  0.00
Modify  | 0.44334    | 0.44334    | 0.44334    |   0.0 |  0.39
Other   |            | 0.06316    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115984 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.798855662196, Press = 2.24987629145968
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -10446.263     -10446.263     -10520.988     -10520.988      289.19554      289.19554      28047.494      28047.494     -552.37785     -552.37785    
     41000  -10444.507     -10444.507     -10519.653     -10519.653      290.82262      290.82262      28089.993      28089.993     -2650.6501     -2650.6501    
Loop time of 113.22 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.763 ns/day, 31.450 hours/ns, 8.832 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    | 112.63     | 112.63     | 112.63     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08479    | 0.08479    | 0.08479    |   0.0 |  0.07
Output  | 0.00020032 | 0.00020032 | 0.00020032 |   0.0 |  0.00
Modify  | 0.44427    | 0.44427    | 0.44427    |   0.0 |  0.39
Other   |            | 0.06387    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115988 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.807603097609, Press = -1.21551707897178
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -10444.507     -10444.507     -10519.653     -10519.653      290.82262      290.82262      28089.993      28089.993     -2650.6501     -2650.6501    
     42000  -10449.208     -10449.208     -10522.8       -10522.8        284.80879      284.80879      27973.776      27973.776      3307.8433      3307.8433    
Loop time of 100.647 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.858 ns/day, 27.957 hours/ns, 9.936 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 100.13     | 100.13     | 100.13     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077147   | 0.077147   | 0.077147   |   0.0 |  0.08
Output  | 0.00016857 | 0.00016857 | 0.00016857 |   0.0 |  0.00
Modify  | 0.382      | 0.382      | 0.382      |   0.0 |  0.38
Other   |            | 0.0582     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115974 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.757136779646, Press = 0.955023645354391
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -10449.208     -10449.208     -10522.8       -10522.8        284.80879      284.80879      27973.776      27973.776      3307.8433      3307.8433    
     43000  -10443.812     -10443.812     -10518.13      -10518.13       287.61953      287.61953      28046.779      28046.779     -136.6152      -136.6152     
Loop time of 99.3018 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.584 hours/ns, 10.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    | 98.797     | 98.797     | 98.797     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075546   | 0.075546   | 0.075546   |   0.0 |  0.08
Output  | 0.0001728  | 0.0001728  | 0.0001728  |   0.0 |  0.00
Modify  | 0.37189    | 0.37189    | 0.37189    |   0.0 |  0.37
Other   |            | 0.05706    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115988 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.759106233341, Press = 2.26935512287721
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -10443.812     -10443.812     -10518.13      -10518.13       287.61953      287.61953      28046.779      28046.779     -136.6152      -136.6152     
     44000  -10445.896     -10445.896     -10520.743     -10520.743      289.66714      289.66714      28062.962      28062.962     -1378.1578     -1378.1578    
Loop time of 96.5465 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.818 hours/ns, 10.358 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.059     | 96.059     | 96.059     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073775   | 0.073775   | 0.073775   |   0.0 |  0.08
Output  | 0.00017086 | 0.00017086 | 0.00017086 |   0.0 |  0.00
Modify  | 0.35666    | 0.35666    | 0.35666    |   0.0 |  0.37
Other   |            | 0.05659    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115982 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.792148733228, Press = 0.478388293431709
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -10445.896     -10445.896     -10520.743     -10520.743      289.66714      289.66714      28062.962      28062.962     -1378.1578     -1378.1578    
     45000  -10445.678     -10445.678     -10521.094     -10521.094      291.8694       291.8694       28004.341      28004.341      1891.7758      1891.7758    
Loop time of 104.078 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.910 hours/ns, 9.608 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.54     | 103.54     | 103.54     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079553   | 0.079553   | 0.079553   |   0.0 |  0.08
Output  | 0.00023293 | 0.00023293 | 0.00023293 |   0.0 |  0.00
Modify  | 0.39608    | 0.39608    | 0.39608    |   0.0 |  0.38
Other   |            | 0.05889    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115982 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.822133410568, Press = 0.776745443155338
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -10445.678     -10445.678     -10521.094     -10521.094      291.8694       291.8694       28004.341      28004.341      1891.7758      1891.7758    
     46000  -10444.192     -10444.192     -10518.095     -10518.095      286.01069      286.01069      28039.088      28039.088      237.57379      237.57379    
Loop time of 97.4768 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.886 ns/day, 27.077 hours/ns, 10.259 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.984     | 96.984     | 96.984     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075064   | 0.075064   | 0.075064   |   0.0 |  0.08
Output  | 0.00017114 | 0.00017114 | 0.00017114 |   0.0 |  0.00
Modify  | 0.36189    | 0.36189    | 0.36189    |   0.0 |  0.37
Other   |            | 0.0557     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115988 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.812123682962, Press = 3.14001933942606
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -10444.192     -10444.192     -10518.095     -10518.095      286.01069      286.01069      28039.088      28039.088      237.57379      237.57379    
     47000  -10441.21      -10441.21      -10520.278     -10520.278      306.00108      306.00108      28090.654      28090.654     -2665.0617     -2665.0617    
Loop time of 96.7085 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.863 hours/ns, 10.340 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.223     | 96.223     | 96.223     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07382    | 0.07382    | 0.07382    |   0.0 |  0.08
Output  | 0.00017058 | 0.00017058 | 0.00017058 |   0.0 |  0.00
Modify  | 0.35604    | 0.35604    | 0.35604    |   0.0 |  0.37
Other   |            | 0.05552    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115982 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.887576967045, Press = 0.346942803771937
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -10441.21      -10441.21      -10520.278     -10520.278      306.00108      306.00108      28090.654      28090.654     -2665.0617     -2665.0617    
     48000  -10444.771     -10444.771     -10519.559     -10519.559      289.44011      289.44011      28022.752      28022.752      927.27151      927.27151    
Loop time of 96.8631 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.892 ns/day, 26.906 hours/ns, 10.324 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    | 96.376     | 96.376     | 96.376     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07461    | 0.07461    | 0.07461    |   0.0 |  0.08
Output  | 0.00017098 | 0.00017098 | 0.00017098 |   0.0 |  0.00
Modify  | 0.35728    | 0.35728    | 0.35728    |   0.0 |  0.37
Other   |            | 0.05494    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115974 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.918276366045, Press = 0.790127688639252
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -10444.771     -10444.771     -10519.559     -10519.559      289.44011      289.44011      28022.752      28022.752      927.27151      927.27151    
     49000  -10443.506     -10443.506     -10520.676     -10520.676      298.65422      298.65422      28037.727      28037.727      157.55938      157.55938    
Loop time of 97.4483 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.887 ns/day, 27.069 hours/ns, 10.262 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.96      | 96.96      | 96.96      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074291   | 0.074291   | 0.074291   |   0.0 |  0.08
Output  | 0.00016878 | 0.00016878 | 0.00016878 |   0.0 |  0.00
Modify  | 0.35835    | 0.35835    | 0.35835    |   0.0 |  0.37
Other   |            | 0.05505    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115976 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.968336539756, Press = 1.52704941180447
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -10443.506     -10443.506     -10520.676     -10520.676      298.65422      298.65422      28037.727      28037.727      157.55938      157.55938    
     50000  -10445.495     -10445.495     -10522.117     -10522.117      296.5386       296.5386       28051.003      28051.003     -846.49162     -846.49162    
Loop time of 96.4719 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.798 hours/ns, 10.366 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    | 95.985     | 95.985     | 95.985     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073469   | 0.073469   | 0.073469   |   0.0 |  0.08
Output  | 0.00017098 | 0.00017098 | 0.00017098 |   0.0 |  0.00
Modify  | 0.35731    | 0.35731    | 0.35731    |   0.0 |  0.37
Other   |            | 0.05576    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115992 ave      115992 max      115992 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115992
Ave neighs/atom = 57.996
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.957444168215, Press = 1.20672904001141
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -10445.495     -10445.495     -10522.117     -10522.117      296.5386       296.5386       28051.003      28051.003     -846.49162     -846.49162    
     51000  -10444.265     -10444.265     -10519.679     -10519.679      291.85709      291.85709      28040.215      28040.215     -19.505885     -19.505885    
Loop time of 102.048 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.847 ns/day, 28.347 hours/ns, 9.799 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.53     | 101.53     | 101.53     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077666   | 0.077666   | 0.077666   |   0.0 |  0.08
Output  | 0.00021044 | 0.00021044 | 0.00021044 |   0.0 |  0.00
Modify  | 0.38405    | 0.38405    | 0.38405    |   0.0 |  0.38
Other   |            | 0.05817    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115974 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.93251151546, Press = 0.583088238440257
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -10444.265     -10444.265     -10519.679     -10519.679      291.85709      291.85709      28040.215      28040.215     -19.505885     -19.505885    
     52000  -10446.759     -10446.759     -10520.11      -10520.11       283.87701      283.87701      28011.426      28011.426      1436.8155      1436.8155    
Loop time of 113.735 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.593 hours/ns, 8.792 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    | 113.14     | 113.14     | 113.14     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084439   | 0.084439   | 0.084439   |   0.0 |  0.07
Output  | 0.00021087 | 0.00021087 | 0.00021087 |   0.0 |  0.00
Modify  | 0.44439    | 0.44439    | 0.44439    |   0.0 |  0.39
Other   |            | 0.0632     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115974 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.915197355917, Press = 1.38343059047158
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -10446.759     -10446.759     -10520.11      -10520.11       283.87701      283.87701      28011.426      28011.426      1436.8155      1436.8155    
     53000  -10443.492     -10443.492     -10520.34      -10520.34       297.40963      297.40963      28068.445      28068.445     -1705.805      -1705.805     
Loop time of 107.281 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.805 ns/day, 29.800 hours/ns, 9.321 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    | 106.73     | 106.73     | 106.73     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080636   | 0.080636   | 0.080636   |   0.0 |  0.08
Output  | 0.00017041 | 0.00017041 | 0.00017041 |   0.0 |  0.00
Modify  | 0.41051    | 0.41051    | 0.41051    |   0.0 |  0.38
Other   |            | 0.06009    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115976 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.89939309194, Press = 1.4820932891402
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -10443.492     -10443.492     -10520.34      -10520.34       297.40963      297.40963      28068.445      28068.445     -1705.805      -1705.805     
     54000  -10442.834     -10442.834     -10518.906     -10518.906      294.40742      294.40742      28055.59       28055.59      -714.83327     -714.83327    
Loop time of 96.7972 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.888 hours/ns, 10.331 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.306     | 96.306     | 96.306     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074228   | 0.074228   | 0.074228   |   0.0 |  0.08
Output  | 0.00017165 | 0.00017165 | 0.00017165 |   0.0 |  0.00
Modify  | 0.36036    | 0.36036    | 0.36036    |   0.0 |  0.37
Other   |            | 0.05634    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115984 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.891577489549, Press = -0.512425052371612
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -10442.834     -10442.834     -10518.906     -10518.906      294.40742      294.40742      28055.59       28055.59      -714.83327     -714.83327    
     55000  -10445.063     -10445.063     -10521.424     -10521.424      295.52532      295.52532      27977.92       27977.92       3345.6285      3345.6285    
Loop time of 102.119 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.846 ns/day, 28.366 hours/ns, 9.793 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.6      | 101.6      | 101.6      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077435   | 0.077435   | 0.077435   |   0.0 |  0.08
Output  | 0.00019674 | 0.00019674 | 0.00019674 |   0.0 |  0.00
Modify  | 0.38553    | 0.38553    | 0.38553    |   0.0 |  0.38
Other   |            | 0.05895    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115988 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.900157451337, Press = 1.3980073037196
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -10445.063     -10445.063     -10521.424     -10521.424      295.52532      295.52532      27977.92       27977.92       3345.6285      3345.6285    
     56000  -10443.472     -10443.472     -10518.463     -10518.463      290.22392      290.22392      28064.668      28064.668     -1237.3566     -1237.3566    
Loop time of 111.72 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.773 ns/day, 31.033 hours/ns, 8.951 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 111.14     | 111.14     | 111.14     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082726   | 0.082726   | 0.082726   |   0.0 |  0.07
Output  | 0.00021499 | 0.00021499 | 0.00021499 |   0.0 |  0.00
Modify  | 0.43494    | 0.43494    | 0.43494    |   0.0 |  0.39
Other   |            | 0.06276    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115980 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.897977096568, Press = 1.60184917036872
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -10443.472     -10443.472     -10518.463     -10518.463      290.22392      290.22392      28064.668      28064.668     -1237.3566     -1237.3566    
     57000  -10446.485     -10446.485     -10520.769     -10520.769      287.4868       287.4868       28039.019      28039.019     -66.803652     -66.803652    
Loop time of 104.686 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.079 hours/ns, 9.552 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.15     | 104.15     | 104.15     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078438   | 0.078438   | 0.078438   |   0.0 |  0.07
Output  | 0.00020445 | 0.00020445 | 0.00020445 |   0.0 |  0.00
Modify  | 0.3991     | 0.3991     | 0.3991     |   0.0 |  0.38
Other   |            | 0.05861    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115978 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.870241493071, Press = 0.381130262567104
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -10446.485     -10446.485     -10520.769     -10520.769      287.4868       287.4868       28039.019      28039.019     -66.803652     -66.803652    
     58000  -10443.929     -10443.929     -10519.414     -10519.414      292.13288      292.13288      28026.812      28026.812      755.30978      755.30978    
Loop time of 96.4883 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.802 hours/ns, 10.364 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.003     | 96.003     | 96.003     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073694   | 0.073694   | 0.073694   |   0.0 |  0.08
Output  | 0.00016891 | 0.00016891 | 0.00016891 |   0.0 |  0.00
Modify  | 0.35562    | 0.35562    | 0.35562    |   0.0 |  0.37
Other   |            | 0.05538    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115982 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.853297434891, Press = 1.1024556587765
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -10443.929     -10443.929     -10519.414     -10519.414      292.13288      292.13288      28026.812      28026.812      755.30978      755.30978    
     59000  -10446.504     -10446.504     -10522.624     -10522.624      294.59152      294.59152      28045.677      28045.677     -505.36535     -505.36535    
Loop time of 96.392 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.776 hours/ns, 10.374 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.907     | 95.907     | 95.907     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07364    | 0.07364    | 0.07364    |   0.0 |  0.08
Output  | 0.00020337 | 0.00020337 | 0.00020337 |   0.0 |  0.00
Modify  | 0.35525    | 0.35525    | 0.35525    |   0.0 |  0.37
Other   |            | 0.05575    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115984 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.81929376511, Press = 1.28113953188157
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -10446.504     -10446.504     -10522.624     -10522.624      294.59152      294.59152      28045.677      28045.677     -505.36535     -505.36535    
     60000  -10441.642     -10441.642     -10519.093     -10519.093      299.74605      299.74605      28065.034      28065.034     -972.34556     -972.34556    
Loop time of 102.857 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.840 ns/day, 28.571 hours/ns, 9.722 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.33     | 102.33     | 102.33     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077545   | 0.077545   | 0.077545   |   0.0 |  0.08
Output  | 0.00023281 | 0.00023281 | 0.00023281 |   0.0 |  0.00
Modify  | 0.38905    | 0.38905    | 0.38905    |   0.0 |  0.38
Other   |            | 0.0587     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115978 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.844986512944, Press = -0.326476692436986
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -10441.642     -10441.642     -10519.093     -10519.093      299.74605      299.74605      28065.034      28065.034     -972.34556     -972.34556    
     61000  -10447.4       -10447.4       -10522.414     -10522.414      290.3099       290.3099       27987.709      27987.709      2689.8154      2689.8154    
Loop time of 101.068 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.855 ns/day, 28.075 hours/ns, 9.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    | 100.55     | 100.55     | 100.55     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076547   | 0.076547   | 0.076547   |   0.0 |  0.08
Output  | 0.00016998 | 0.00016998 | 0.00016998 |   0.0 |  0.00
Modify  | 0.38088    | 0.38088    | 0.38088    |   0.0 |  0.38
Other   |            | 0.0576     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115974 ave      115974 max      115974 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115974
Ave neighs/atom = 57.987
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.845361527053, Press = 0.866026475606257
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -10447.4       -10447.4       -10522.414     -10522.414      290.3099       290.3099       27987.709      27987.709      2689.8154      2689.8154    
     62000  -10443.603     -10443.603     -10520.219     -10520.219      296.51425      296.51425      28061.744      28061.744     -1240.4931     -1240.4931    
Loop time of 99.3617 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.870 ns/day, 27.600 hours/ns, 10.064 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.86      | 98.86      | 98.86      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07414    | 0.07414    | 0.07414    |   0.0 |  0.07
Output  | 0.0002617  | 0.0002617  | 0.0002617  |   0.0 |  0.00
Modify  | 0.36991    | 0.36991    | 0.36991    |   0.0 |  0.37
Other   |            | 0.05738    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.829309409814, Press = 1.48671860237407
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -10443.603     -10443.603     -10520.219     -10520.219      296.51425      296.51425      28061.744      28061.744     -1240.4931     -1240.4931    
     63000  -10446.077     -10446.077     -10521.39      -10521.39       291.46997      291.46997      28054.118      28054.118     -797.668       -797.668      
Loop time of 98.3363 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.879 ns/day, 27.316 hours/ns, 10.169 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.84      | 97.84      | 97.84      |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075149   | 0.075149   | 0.075149   |   0.0 |  0.08
Output  | 0.000179   | 0.000179   | 0.000179   |   0.0 |  0.00
Modify  | 0.3646     | 0.3646     | 0.3646     |   0.0 |  0.37
Other   |            | 0.05661    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115972 ave      115972 max      115972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115972
Ave neighs/atom = 57.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.792883767517, Press = 0.267708918389978
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -10446.077     -10446.077     -10521.39      -10521.39       291.46997      291.46997      28054.118      28054.118     -797.668       -797.668      
     64000  -10445.362     -10445.362     -10521.11      -10521.11       293.15349      293.15349      28024.884      28024.884      725.22363      725.22363    
Loop time of 109.513 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.789 ns/day, 30.420 hours/ns, 9.131 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    | 108.95     | 108.95     | 108.95     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081537   | 0.081537   | 0.081537   |   0.0 |  0.07
Output  | 0.00017123 | 0.00017123 | 0.00017123 |   0.0 |  0.00
Modify  | 0.42351    | 0.42351    | 0.42351    |   0.0 |  0.39
Other   |            | 0.06192    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115986 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.791916044911, Press = 0.740929744431432
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -10445.362     -10445.362     -10521.11      -10521.11       293.15349      293.15349      28024.884      28024.884      725.22363      725.22363    
     65000  -10441.309     -10441.309     -10517.892     -10517.892      296.38442      296.38442      28044.705      28044.705      109.16011      109.16011    
Loop time of 96.6988 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.861 hours/ns, 10.341 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.212     | 96.212     | 96.212     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074029   | 0.074029   | 0.074029   |   0.0 |  0.08
Output  | 0.00016978 | 0.00016978 | 0.00016978 |   0.0 |  0.00
Modify  | 0.35735    | 0.35735    | 0.35735    |   0.0 |  0.37
Other   |            | 0.05475    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115984 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.81242130637, Press = 0.927707376316977
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -10441.309     -10441.309     -10517.892     -10517.892      296.38442      296.38442      28044.705      28044.705      109.16011      109.16011    
     66000  -10445.68      -10445.68      -10519.313     -10519.313      284.96562      284.96562      28043.846      28043.846     -207.25172     -207.25172    
Loop time of 103.777 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.827 hours/ns, 9.636 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.25     | 103.25     | 103.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078119   | 0.078119   | 0.078119   |   0.0 |  0.08
Output  | 0.00022826 | 0.00022826 | 0.00022826 |   0.0 |  0.00
Modify  | 0.39199    | 0.39199    | 0.39199    |   0.0 |  0.38
Other   |            | 0.05853    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.842985203806, Press = 0.683446776739907
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -10445.68      -10445.68      -10519.313     -10519.313      284.96562      284.96562      28043.846      28043.846     -207.25172     -207.25172    
     67000  -10441.375     -10441.375     -10518.433     -10518.433      298.22502      298.22502      28039.862      28039.862      322.99187      322.99187    
Loop time of 111.124 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.778 ns/day, 30.868 hours/ns, 8.999 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 110.55     | 110.55     | 110.55     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082784   | 0.082784   | 0.082784   |   0.0 |  0.07
Output  | 0.00017336 | 0.00017336 | 0.00017336 |   0.0 |  0.00
Modify  | 0.43431    | 0.43431    | 0.43431    |   0.0 |  0.39
Other   |            | 0.06149    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115978 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.88517339405, Press = 0.418128164078509
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -10441.375     -10441.375     -10518.433     -10518.433      298.22502      298.22502      28039.862      28039.862      322.99187      322.99187    
     68000  -10446.472     -10446.472     -10521.666     -10521.666      291.00816      291.00816      28011.81       28011.81       1454.4647      1454.4647    
Loop time of 96.2634 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.898 ns/day, 26.740 hours/ns, 10.388 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.778     | 95.778     | 95.778     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073439   | 0.073439   | 0.073439   |   0.0 |  0.08
Output  | 0.00017152 | 0.00017152 | 0.00017152 |   0.0 |  0.00
Modify  | 0.3562     | 0.3562     | 0.3562     |   0.0 |  0.37
Other   |            | 0.05544    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115968 ave      115968 max      115968 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115968
Ave neighs/atom = 57.984
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.905272196192, Press = 1.25141268869787
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -10446.472     -10446.472     -10521.666     -10521.666      291.00816      291.00816      28011.81       28011.81       1454.4647      1454.4647    
     69000  -10441.783     -10441.783     -10518.182     -10518.182      295.67127      295.67127      28101.74       28101.74      -3007.4545     -3007.4545    
Loop time of 96.39 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.775 hours/ns, 10.375 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.904     | 95.904     | 95.904     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073751   | 0.073751   | 0.073751   |   0.0 |  0.08
Output  | 0.00046908 | 0.00046908 | 0.00046908 |   0.0 |  0.00
Modify  | 0.35586    | 0.35586    | 0.35586    |   0.0 |  0.37
Other   |            | 0.05563    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115970 ave      115970 max      115970 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115970
Ave neighs/atom = 57.985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.941302347368, Press = 1.0366470428683
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -10441.783     -10441.783     -10518.182     -10518.182      295.67127      295.67127      28101.74       28101.74      -3007.4545     -3007.4545    
     70000  -10446.31      -10446.31      -10521.457     -10521.457      290.82931      290.82931      28037.803      28037.803      101.88005      101.88005    
Loop time of 96.4804 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.800 hours/ns, 10.365 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.995     | 95.995     | 95.995     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073955   | 0.073955   | 0.073955   |   0.0 |  0.08
Output  | 0.00020478 | 0.00020478 | 0.00020478 |   0.0 |  0.00
Modify  | 0.35611    | 0.35611    | 0.35611    |   0.0 |  0.37
Other   |            | 0.05489    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115972 ave      115972 max      115972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115972
Ave neighs/atom = 57.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.973801439974, Press = -0.339571299444952
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -10446.31      -10446.31      -10521.457     -10521.457      290.82931      290.82931      28037.803      28037.803      101.88005      101.88005    
     71000  -10443.53      -10443.53      -10519.88      -10519.88       295.48531      295.48531      28019.162      28019.162      1314.4648      1314.4648    
Loop time of 100.397 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.861 ns/day, 27.888 hours/ns, 9.960 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 99.887     | 99.887     | 99.887     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076128   | 0.076128   | 0.076128   |   0.0 |  0.08
Output  | 0.00021653 | 0.00021653 | 0.00021653 |   0.0 |  0.00
Modify  | 0.37661    | 0.37661    | 0.37661    |   0.0 |  0.38
Other   |            | 0.05717    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115986 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.978416825062, Press = 0.932188904016782
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -10443.53      -10443.53      -10519.88      -10519.88       295.48531      295.48531      28019.162      28019.162      1314.4648      1314.4648    
     72000  -10447.459     -10447.459     -10522.681     -10522.681      291.11912      291.11912      28056.844      28056.844     -1233.8621     -1233.8621    
Loop time of 104.055 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.904 hours/ns, 9.610 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    | 103.52     | 103.52     | 103.52     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078229   | 0.078229   | 0.078229   |   0.0 |  0.08
Output  | 0.00017225 | 0.00017225 | 0.00017225 |   0.0 |  0.00
Modify  | 0.39475    | 0.39475    | 0.39475    |   0.0 |  0.38
Other   |            | 0.05868    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115972 ave      115972 max      115972 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115972
Ave neighs/atom = 57.986
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.982638668526, Press = 0.746486326075998
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -10447.459     -10447.459     -10522.681     -10522.681      291.11912      291.11912      28056.844      28056.844     -1233.8621     -1233.8621    
     73000  -10443.236     -10443.236     -10517.816     -10517.816      288.63308      288.63308      28042.884      28042.884      45.626961      45.626961    
Loop time of 96.3979 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.777 hours/ns, 10.374 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.912     | 95.912     | 95.912     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073258   | 0.073258   | 0.073258   |   0.0 |  0.08
Output  | 0.00016908 | 0.00016908 | 0.00016908 |   0.0 |  0.00
Modify  | 0.35767    | 0.35767    | 0.35767    |   0.0 |  0.37
Other   |            | 0.05526    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115994 ave      115994 max      115994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115994
Ave neighs/atom = 57.997
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.965788480213, Press = 0.290824708992161
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -10443.236     -10443.236     -10517.816     -10517.816      288.63308      288.63308      28042.884      28042.884      45.626961      45.626961    
     74000  -10449.637     -10449.637     -10524.59      -10524.59       290.07536      290.07536      28003.961      28003.961      1590.2114      1590.2114    
Loop time of 108.964 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.793 ns/day, 30.268 hours/ns, 9.177 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.4      | 108.4      | 108.4      |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081504   | 0.081504   | 0.081504   |   0.0 |  0.07
Output  | 0.00017011 | 0.00017011 | 0.00017011 |   0.0 |  0.00
Modify  | 0.42391    | 0.42391    | 0.42391    |   0.0 |  0.39
Other   |            | 0.0619     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115966 ave      115966 max      115966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115966
Ave neighs/atom = 57.983
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.950819457502, Press = 1.05259334563413
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -10449.637     -10449.637     -10524.59      -10524.59       290.07536      290.07536      28003.961      28003.961      1590.2114      1590.2114    
     75000  -10443.973     -10443.973     -10521.469     -10521.469      299.91839      299.91839      28103.174      28103.174     -3364.7755     -3364.7755    
Loop time of 98.7245 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.875 ns/day, 27.423 hours/ns, 10.129 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 98.22      | 98.22      | 98.22      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076763   | 0.076763   | 0.076763   |   0.0 |  0.08
Output  | 0.00017103 | 0.00017103 | 0.00017103 |   0.0 |  0.00
Modify  | 0.37066    | 0.37066    | 0.37066    |   0.0 |  0.38
Other   |            | 0.05732    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115984 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.931627913702, Press = 1.14217502890142
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -10443.973     -10443.973     -10521.469     -10521.469      299.91839      299.91839      28103.174      28103.174     -3364.7755     -3364.7755    
     76000  -10450.283     -10450.283     -10523.326     -10523.326      282.6848       282.6848       28038.641      28038.641     -287.77458     -287.77458    
Loop time of 97.4229 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.887 ns/day, 27.062 hours/ns, 10.265 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.93      | 96.93      | 96.93      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07588    | 0.07588    | 0.07588    |   0.0 |  0.08
Output  | 0.00017002 | 0.00017002 | 0.00017002 |   0.0 |  0.00
Modify  | 0.36061    | 0.36061    | 0.36061    |   0.0 |  0.37
Other   |            | 0.05626    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115966 ave      115966 max      115966 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115966
Ave neighs/atom = 57.983
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.902651786768, Press = -0.249605474675269
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -10450.283     -10450.283     -10523.326     -10523.326      282.6848       282.6848       28038.641      28038.641     -287.77458     -287.77458    
     77000  -10444.803     -10444.803     -10520.245     -10520.245      291.9669       291.9669       28016.305      28016.305      1426.2374      1426.2374    
Loop time of 97.0495 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.890 ns/day, 26.958 hours/ns, 10.304 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.557     | 96.557     | 96.557     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075857   | 0.075857   | 0.075857   |   0.0 |  0.08
Output  | 0.00017035 | 0.00017035 | 0.00017035 |   0.0 |  0.00
Modify  | 0.36063    | 0.36063    | 0.36063    |   0.0 |  0.37
Other   |            | 0.05598    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115990 ave      115990 max      115990 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115990
Ave neighs/atom = 57.995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.869392613128, Press = 0.753795843346367
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -10444.803     -10444.803     -10520.245     -10520.245      291.9669       291.9669       28016.305      28016.305      1426.2374      1426.2374    
     78000  -10445.852     -10445.852     -10518.353     -10518.353      280.58752      280.58752      28060.014      28060.014     -695.43372     -695.43372    
Loop time of 96.9246 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.891 ns/day, 26.923 hours/ns, 10.317 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.433     | 96.433     | 96.433     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075667   | 0.075667   | 0.075667   |   0.0 |  0.08
Output  | 0.00016989 | 0.00016989 | 0.00016989 |   0.0 |  0.00
Modify  | 0.35991    | 0.35991    | 0.35991    |   0.0 |  0.37
Other   |            | 0.05623    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115978 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.865353128072, Press = 0.815512190265944
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -10445.852     -10445.852     -10518.353     -10518.353      280.58752      280.58752      28060.014      28060.014     -695.43372     -695.43372    
     79000  -10441.127     -10441.127     -10519.728     -10519.728      304.19692      304.19692      28051.918      28051.918     -421.00865     -421.00865    
Loop time of 96.713 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.865 hours/ns, 10.340 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.222     | 96.222     | 96.222     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075541   | 0.075541   | 0.075541   |   0.0 |  0.08
Output  | 0.00017189 | 0.00017189 | 0.00017189 |   0.0 |  0.00
Modify  | 0.3588     | 0.3588     | 0.3588     |   0.0 |  0.37
Other   |            | 0.05607    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115986 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.891139444235, Press = -0.0115103370773622
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -10441.127     -10441.127     -10519.728     -10519.728      304.19692      304.19692      28051.918      28051.918     -421.00865     -421.00865    
     80000  -10446.143     -10446.143     -10520.343     -10520.343      287.16305      287.16305      28009.131      28009.131      1636.1677      1636.1677    
Loop time of 96.6667 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.852 hours/ns, 10.345 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.176     | 96.176     | 96.176     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075292   | 0.075292   | 0.075292   |   0.0 |  0.08
Output  | 0.00017254 | 0.00017254 | 0.00017254 |   0.0 |  0.00
Modify  | 0.35914    | 0.35914    | 0.35914    |   0.0 |  0.37
Other   |            | 0.05579    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115982 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.89954880888, Press = 0.794078544998238
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -10446.143     -10446.143     -10520.343     -10520.343      287.16305      287.16305      28009.131      28009.131      1636.1677      1636.1677    
     81000  -10444.319     -10444.319     -10519.727     -10519.727      291.83495      291.83495      28068.843      28068.843     -1472.4046     -1472.4046    
Loop time of 96.6802 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.856 hours/ns, 10.343 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.19      | 96.19      | 96.19      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07542    | 0.07542    | 0.07542    |   0.0 |  0.08
Output  | 0.00017046 | 0.00017046 | 0.00017046 |   0.0 |  0.00
Modify  | 0.3582     | 0.3582     | 0.3582     |   0.0 |  0.37
Other   |            | 0.0564     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115978 ave      115978 max      115978 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115978
Ave neighs/atom = 57.989
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.902998584135, Press = 0.883373134577865
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -10444.319     -10444.319     -10519.727     -10519.727      291.83495      291.83495      28068.843      28068.843     -1472.4046     -1472.4046    
     82000  -10445.553     -10445.553     -10521.64      -10521.64       294.46204      294.46204      28051.691      28051.691     -720.37033     -720.37033    
Loop time of 96.4501 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.792 hours/ns, 10.368 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.96      | 95.96      | 95.96      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075192   | 0.075192   | 0.075192   |   0.0 |  0.08
Output  | 0.00016981 | 0.00016981 | 0.00016981 |   0.0 |  0.00
Modify  | 0.35859    | 0.35859    | 0.35859    |   0.0 |  0.37
Other   |            | 0.05639    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115976 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.918064862102, Press = -0.0475770289097731
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -10445.553     -10445.553     -10521.64      -10521.64       294.46204      294.46204      28051.691      28051.691     -720.37033     -720.37033    
     83000  -10447.562     -10447.562     -10522.912     -10522.912      291.61281      291.61281      28002.394      28002.394      1910.09        1910.09      
Loop time of 96.3334 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.759 hours/ns, 10.381 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.844     | 95.844     | 95.844     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074703   | 0.074703   | 0.074703   |   0.0 |  0.08
Output  | 0.00017481 | 0.00017481 | 0.00017481 |   0.0 |  0.00
Modify  | 0.35858    | 0.35858    | 0.35858    |   0.0 |  0.37
Other   |            | 0.05633    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115982 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.930025903991, Press = 0.64537558412009
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -10447.562     -10447.562     -10522.912     -10522.912      291.61281      291.61281      28002.394      28002.394      1910.09        1910.09      
     84000  -10443.766     -10443.766     -10519.373     -10519.373      292.60643      292.60643      28072.271      28072.271     -1537.241      -1537.241     
Loop time of 96.4845 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.895 ns/day, 26.801 hours/ns, 10.364 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.994     | 95.994     | 95.994     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074673   | 0.074673   | 0.074673   |   0.0 |  0.08
Output  | 0.00017181 | 0.00017181 | 0.00017181 |   0.0 |  0.00
Modify  | 0.35882    | 0.35882    | 0.35882    |   0.0 |  0.37
Other   |            | 0.05659    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115986 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.90770998111, Press = 1.19326464277863
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -10443.766     -10443.766     -10519.373     -10519.373      292.60643      292.60643      28072.271      28072.271     -1537.241      -1537.241     
     85000  -10448.238     -10448.238     -10521.642     -10521.642      284.0799       284.0799       28064.692      28064.692     -1449.1672     -1449.1672    
Loop time of 96.4019 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.896 ns/day, 26.778 hours/ns, 10.373 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.912     | 95.912     | 95.912     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07515    | 0.07515    | 0.07515    |   0.0 |  0.08
Output  | 0.00017295 | 0.00017295 | 0.00017295 |   0.0 |  0.00
Modify  | 0.35831    | 0.35831    | 0.35831    |   0.0 |  0.37
Other   |            | 0.05643    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115980 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.880460274001, Press = -0.518646213354157
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -10448.238     -10448.238     -10521.642     -10521.642      284.0799       284.0799       28064.692      28064.692     -1449.1672     -1449.1672    
     86000  -10446.098     -10446.098     -10518.884     -10518.884      281.68796      281.68796      28006.827      28006.827      1995.9911      1995.9911    
Loop time of 96.6971 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.860 hours/ns, 10.342 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.207     | 96.207     | 96.207     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075415   | 0.075415   | 0.075415   |   0.0 |  0.08
Output  | 0.00017163 | 0.00017163 | 0.00017163 |   0.0 |  0.00
Modify  | 0.3582     | 0.3582     | 0.3582     |   0.0 |  0.37
Other   |            | 0.05626    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115988 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.883509109975, Press = 0.598579795595072
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -10446.098     -10446.098     -10518.884     -10518.884      281.68796      281.68796      28006.827      28006.827      1995.9911      1995.9911    
     87000  -10449.165     -10449.165     -10522.606     -10522.606      284.22258      284.22258      28040.786      28040.786     -277.79149     -277.79149    
Loop time of 96.3342 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.760 hours/ns, 10.381 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.844     | 95.844     | 95.844     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074979   | 0.074979   | 0.074979   |   0.0 |  0.08
Output  | 0.00017261 | 0.00017261 | 0.00017261 |   0.0 |  0.00
Modify  | 0.35879    | 0.35879    | 0.35879    |   0.0 |  0.37
Other   |            | 0.05603    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115988 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.868750226345, Press = 0.607084195981437
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -10449.165     -10449.165     -10522.606     -10522.606      284.22258      284.22258      28040.786      28040.786     -277.79149     -277.79149    
     88000  -10443.564     -10443.564     -10520.994     -10520.994      299.66002      299.66002      28053.612      28053.612     -649.22069     -649.22069    
Loop time of 96.3325 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.897 ns/day, 26.759 hours/ns, 10.381 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 95.843     | 95.843     | 95.843     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074824   | 0.074824   | 0.074824   |   0.0 |  0.08
Output  | 0.00017038 | 0.00017038 | 0.00017038 |   0.0 |  0.00
Modify  | 0.35768    | 0.35768    | 0.35768    |   0.0 |  0.37
Other   |            | 0.05658    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115976 ave      115976 max      115976 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115976
Ave neighs/atom = 57.988
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.856708456895, Press = 0.289547892106643
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -10443.564     -10443.564     -10520.994     -10520.994      299.66002      299.66002      28053.612      28053.612     -649.22069     -649.22069    
     89000  -10447.049     -10447.049     -10523.07      -10523.07       294.20809      294.20809      28021.642      28021.642      994.00808      994.00808    
Loop time of 104.158 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.933 hours/ns, 9.601 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.62     | 103.62     | 103.62     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078014   | 0.078014   | 0.078014   |   0.0 |  0.07
Output  | 0.00016879 | 0.00016879 | 0.00016879 |   0.0 |  0.00
Modify  | 0.3983     | 0.3983     | 0.3983     |   0.0 |  0.38
Other   |            | 0.05941    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115980 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.845197592655, Press = 0.423704717641353
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -10447.049     -10447.049     -10523.07      -10523.07       294.20809      294.20809      28021.642      28021.642      994.00808      994.00808    
     90000  -10439.738     -10439.738     -10516.406     -10516.406      296.71355      296.71355      28053.133      28053.133     -93.987338     -93.987338    
Loop time of 96.1388 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.899 ns/day, 26.705 hours/ns, 10.402 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    | 95.655     | 95.655     | 95.655     |   0.0 | 99.50
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.072529   | 0.072529   | 0.072529   |   0.0 |  0.08
Output  | 0.00016718 | 0.00016718 | 0.00016718 |   0.0 |  0.00
Modify  | 0.35508    | 0.35508    | 0.35508    |   0.0 |  0.37
Other   |            | 0.05603    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115982 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.865069590304, Press = 1.01643936163516
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     90000  -10439.738     -10439.738     -10516.406     -10516.406      296.71355      296.71355      28053.133      28053.133     -93.987338     -93.987338    
     91000  -10446.164     -10446.164     -10520.339     -10520.339      287.06719      287.06719      28068.404      28068.404     -1509.1314     -1509.1314    
Loop time of 104.401 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.828 ns/day, 29.000 hours/ns, 9.578 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.86     | 103.86     | 103.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.077872   | 0.077872   | 0.077872   |   0.0 |  0.07
Output  | 0.00016979 | 0.00016979 | 0.00016979 |   0.0 |  0.00
Modify  | 0.40013    | 0.40013    | 0.40013    |   0.0 |  0.38
Other   |            | 0.05914    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115986 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.883870641189, Press = 0.113873362916484
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     91000  -10446.164     -10446.164     -10520.339     -10520.339      287.06719      287.06719      28068.404      28068.404     -1509.1314     -1509.1314    
     92000  -10441.33      -10441.33      -10518.982     -10518.982      300.5194       300.5194       28006.152      28006.152      2142.6039      2142.6039    
Loop time of 108.337 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.798 ns/day, 30.094 hours/ns, 9.230 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    | 107.78     | 107.78     | 107.78     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082491   | 0.082491   | 0.082491   |   0.0 |  0.08
Output  | 0.00021868 | 0.00021868 | 0.00021868 |   0.0 |  0.00
Modify  | 0.41866    | 0.41866    | 0.41866    |   0.0 |  0.39
Other   |            | 0.06092    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115980 ave      115980 max      115980 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115980
Ave neighs/atom = 57.99
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.905737865357, Press = 0.194864816920957
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     92000  -10441.33      -10441.33      -10518.982     -10518.982      300.5194       300.5194       28006.152      28006.152      2142.6039      2142.6039    
     93000  -10445.515     -10445.515     -10520.811     -10520.811      291.40388      291.40388      28043.504      28043.504     -132.98306     -132.98306    
Loop time of 113.586 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.552 hours/ns, 8.804 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    | 112.99     | 112.99     | 112.99     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.085923   | 0.085923   | 0.085923   |   0.0 |  0.08
Output  | 0.00016781 | 0.00016781 | 0.00016781 |   0.0 |  0.00
Modify  | 0.44831    | 0.44831    | 0.44831    |   0.0 |  0.39
Other   |            | 0.06307    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115982 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.907261479411, Press = 1.18379610814042
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     93000  -10445.515     -10445.515     -10520.811     -10520.811      291.40388      291.40388      28043.504      28043.504     -132.98306     -132.98306    
     94000  -10443.564     -10443.564     -10517.637     -10517.637      286.6702       286.6702       28070.757      28070.757     -1300.1095     -1300.1095    
Loop time of 97.8255 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.883 ns/day, 27.174 hours/ns, 10.222 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 97.331     | 97.331     | 97.331     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.073905   | 0.073905   | 0.073905   |   0.0 |  0.08
Output  | 0.00017012 | 0.00017012 | 0.00017012 |   0.0 |  0.00
Modify  | 0.36409    | 0.36409    | 0.36409    |   0.0 |  0.37
Other   |            | 0.05619    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115988 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.888742676311, Press = 0.161188037938194
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     94000  -10443.564     -10443.564     -10517.637     -10517.637      286.6702       286.6702       28070.757      28070.757     -1300.1095     -1300.1095    
     95000  -10446.315     -10446.315     -10520.694     -10520.694      287.85622      287.85622      28022.372      28022.372      899.51543      899.51543    
Loop time of 113.481 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.761 ns/day, 31.522 hours/ns, 8.812 timesteps/s
99.8% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.88     | 112.88     | 112.88     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08478    | 0.08478    | 0.08478    |   0.0 |  0.07
Output  | 0.00016891 | 0.00016891 | 0.00016891 |   0.0 |  0.00
Modify  | 0.4472     | 0.4472     | 0.4472     |   0.0 |  0.39
Other   |            | 0.06377    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115986 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.866755674982, Press = 0.227333823840855
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     95000  -10446.315     -10446.315     -10520.694     -10520.694      287.85622      287.85622      28022.372      28022.372      899.51543      899.51543    
     96000  -10447.358     -10447.358     -10522.212     -10522.212      289.69102      289.69102      28037.857      28037.857     -72.929398     -72.929398    
Loop time of 112.786 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.766 ns/day, 31.330 hours/ns, 8.866 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.19     | 112.19     | 112.19     |   0.0 | 99.47
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084452   | 0.084452   | 0.084452   |   0.0 |  0.07
Output  | 0.00021314 | 0.00021314 | 0.00021314 |   0.0 |  0.00
Modify  | 0.44482    | 0.44482    | 0.44482    |   0.0 |  0.39
Other   |            | 0.06287    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115986 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.855197093198, Press = 0.688170951887631
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     96000  -10447.358     -10447.358     -10522.212     -10522.212      289.69102      289.69102      28037.857      28037.857     -72.929398     -72.929398    
     97000  -10442.578     -10442.578     -10519.852     -10519.852      299.05926      299.05926      28066.361      28066.361     -1350.497      -1350.497     
Loop time of 113.138 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.764 ns/day, 31.427 hours/ns, 8.839 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 112.55     | 112.55     | 112.55     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084373   | 0.084373   | 0.084373   |   0.0 |  0.07
Output  | 0.00017035 | 0.00017035 | 0.00017035 |   0.0 |  0.00
Modify  | 0.44498    | 0.44498    | 0.44498    |   0.0 |  0.39
Other   |            | 0.0629     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115982 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.858849693216, Press = 0.249236687461689
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     97000  -10442.578     -10442.578     -10519.852     -10519.852      299.05926      299.05926      28066.361      28066.361     -1350.497      -1350.497     
     98000  -10446.395     -10446.395     -10519.231     -10519.231      281.8799       281.8799       27998.729      27998.729      2279.8668      2279.8668    
Loop time of 112.609 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.767 ns/day, 31.280 hours/ns, 8.880 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    | 112.02     | 112.02     | 112.02     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084224   | 0.084224   | 0.084224   |   0.0 |  0.07
Output  | 0.00016838 | 0.00016838 | 0.00016838 |   0.0 |  0.00
Modify  | 0.44059    | 0.44059    | 0.44059    |   0.0 |  0.39
Other   |            | 0.06242    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115986 ave      115986 max      115986 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115986
Ave neighs/atom = 57.993
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.87383011325, Press = -0.0300901827359312
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     98000  -10446.395     -10446.395     -10519.231     -10519.231      281.8799       281.8799       27998.729      27998.729      2279.8668      2279.8668    
     99000  -10440.446     -10440.446     -10518.466     -10518.466      301.94406      301.94406      28027.515      28027.515      1046.5629      1046.5629    
Loop time of 113.725 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.760 ns/day, 31.590 hours/ns, 8.793 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 113.13     | 113.13     | 113.13     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084804   | 0.084804   | 0.084804   |   0.0 |  0.07
Output  | 0.00016751 | 0.00016751 | 0.00016751 |   0.0 |  0.00
Modify  | 0.44431    | 0.44431    | 0.44431    |   0.0 |  0.39
Other   |            | 0.06273    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115988 ave      115988 max      115988 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115988
Ave neighs/atom = 57.994
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.897075534186, Press = 1.35779555223282
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     99000  -10440.446     -10440.446     -10518.466     -10518.466      301.94406      301.94406      28027.515      28027.515      1046.5629      1046.5629    
    100000  -10446.106     -10446.106     -10519.669     -10519.669      284.69905      284.69905      28070.335      28070.335     -1404.5263     -1404.5263    
Loop time of 105.214 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.226 hours/ns, 9.504 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.67     | 104.67     | 104.67     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079536   | 0.079536   | 0.079536   |   0.0 |  0.08
Output  | 0.0004796  | 0.0004796  | 0.0004796  |   0.0 |  0.00
Modify  | 0.40544    | 0.40544    | 0.40544    |   0.0 |  0.39
Other   |            | 0.05934    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115982 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.910469407022, Press = 0.279980213934842
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    100000  -10446.106     -10446.106     -10519.669     -10519.669      284.69905      284.69905      28070.335      28070.335     -1404.5263     -1404.5263    
    101000  -10443.676     -10443.676     -10519.362     -10519.362      292.91198      292.91198      28028.337      28028.337      879.37463      879.37463    
Loop time of 109.331 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.790 ns/day, 30.370 hours/ns, 9.147 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 108.76     | 108.76     | 108.76     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08153    | 0.08153    | 0.08153    |   0.0 |  0.07
Output  | 0.00021282 | 0.00021282 | 0.00021282 |   0.0 |  0.00
Modify  | 0.42522    | 0.42522    | 0.42522    |   0.0 |  0.39
Other   |            | 0.06149    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115982 ave      115982 max      115982 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115982
Ave neighs/atom = 57.991
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.938456120914, Press = 0.266213925508728
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    101000  -10443.676     -10443.676     -10519.362     -10519.362      292.91198      292.91198      28028.337      28028.337      879.37463      879.37463    
    102000  -10446.609     -10446.609     -10521.799     -10521.799      290.99258      290.99258      28043.409      28043.409     -272.20899     -272.20899    
Loop time of 96.6582 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.894 ns/day, 26.850 hours/ns, 10.346 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 96.166     | 96.166     | 96.166     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.074626   | 0.074626   | 0.074626   |   0.0 |  0.08
Output  | 0.00017114 | 0.00017114 | 0.00017114 |   0.0 |  0.00
Modify  | 0.36094    | 0.36094    | 0.36094    |   0.0 |  0.37
Other   |            | 0.05621    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115984 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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.960046135727, Press = 0.692492695399375
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 = 5.6
  ghost atom cutoff = 5.6
  binsize = 2.8, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 5.6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.701 | 3.701 | 3.701 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
    102000  -10446.609     -10446.609     -10521.799     -10521.799      290.99258      290.99258      28043.409      28043.409     -272.20899     -272.20899    
    103000  -10444.319     -10444.319     -10518.731     -10518.731      287.98365      287.98365      28059.153      28059.153     -897.65883     -897.65883    
Loop time of 96.8054 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.893 ns/day, 26.890 hours/ns, 10.330 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    | 96.314     | 96.314     | 96.314     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.075105   | 0.075105   | 0.075105   |   0.0 |  0.08
Output  | 0.00017009 | 0.00017009 | 0.00017009 |   0.0 |  0.00
Modify  | 0.36082    | 0.36082    | 0.36082    |   0.0 |  0.37
Other   |            | 0.05547    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           2941 ave        2941 max        2941 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:       115984 ave      115984 max      115984 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 115984
Ave neighs/atom = 57.992
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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
28040.797016996

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0