# 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.031088910996914*${_u_distance}
variable latticeconst_converted equal 3.031088910996914*1
lattice       bcc  ${latticeconst_converted}
lattice       bcc  3.03108891099691
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.002 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_ShimLeeFleury_2011_VH__MO_072444764353_002
pair_coeff * * V
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 50.9415

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

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

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

Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 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  -10519.085     -10519.085     -10600         -10600          313.15         313.15         27848.129      27848.129      3103.5097      3103.5097    
      1000  -10430.527     -10430.527     -10519.11      -10519.11       342.82235      342.82235      28029.065      28029.065      1412.4185      1412.4185    
Loop time of 94.9501 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.910 ns/day, 26.375 hours/ns, 10.532 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    | 94.468     | 94.468     | 94.468     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076845   | 0.076845   | 0.076845   |   0.0 |  0.08
Output  | 0.00021828 | 0.00021828 | 0.00021828 |   0.0 |  0.00
Modify  | 0.34922    | 0.34922    | 0.34922    |   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:       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 = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -10430.527     -10430.527     -10519.11      -10519.11       342.82235      342.82235      28029.065      28029.065      1412.4185      1412.4185    
      2000  -10435.073     -10435.073     -10514.938     -10514.938      309.08462      309.08462      28054.465      28054.465      111.96115      111.96115    
Loop time of 99.9427 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.864 ns/day, 27.762 hours/ns, 10.006 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    | 99.455     | 99.455     | 99.455     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080253   | 0.080253   | 0.080253   |   0.0 |  0.08
Output  | 0.00024729 | 0.00024729 | 0.00024729 |   0.0 |  0.00
Modify  | 0.35018    | 0.35018    | 0.35018    |   0.0 |  0.35
Other   |            | 0.0567     |            |       |  0.06

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

Total # of neighbors = 118924
Ave neighs/atom = 59.462
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -10435.073     -10435.073     -10514.938     -10514.938      309.08462      309.08462      28054.465      28054.465      111.96115      111.96115    
      3000  -10434.031     -10434.031     -10513.884     -10513.884      309.03852      309.03852      28079.076      28079.076     -1318.7622     -1318.7622    
Loop time of 101.074 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.855 ns/day, 28.076 hours/ns, 9.894 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.58     | 100.58     | 100.58     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080453   | 0.080453   | 0.080453   |   0.0 |  0.08
Output  | 0.00023488 | 0.00023488 | 0.00023488 |   0.0 |  0.00
Modify  | 0.35479    | 0.35479    | 0.35479    |   0.0 |  0.35
Other   |            | 0.0568     |            |       |  0.06

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

Total # of neighbors = 119062
Ave neighs/atom = 59.531
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -10434.031     -10434.031     -10513.884     -10513.884      309.03852      309.03852      28079.076      28079.076     -1318.7622     -1318.7622    
      4000  -10433.686     -10433.686     -10513.654     -10513.654      309.48341      309.48341      28073.99       28073.99      -691.73255     -691.73255    
Loop time of 101.057 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.855 ns/day, 28.071 hours/ns, 9.895 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.56     | 100.56     | 100.56     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080647   | 0.080647   | 0.080647   |   0.0 |  0.08
Output  | 0.00027186 | 0.00027186 | 0.00027186 |   0.0 |  0.00
Modify  | 0.35554    | 0.35554    | 0.35554    |   0.0 |  0.35
Other   |            | 0.05722    |            |       |  0.06

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

Total # of neighbors = 119032
Ave neighs/atom = 59.516
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 0, Press = 0
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -10433.686     -10433.686     -10513.654     -10513.654      309.48341      309.48341      28073.99       28073.99      -691.73255     -691.73255    
      5000  -10432.359     -10432.359     -10516.738     -10516.738      326.55683      326.55683      28074.254      28074.254     -771.68088     -771.68088    
Loop time of 102.952 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.598 hours/ns, 9.713 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    | 102.45     | 102.45     | 102.45     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081466   | 0.081466   | 0.081466   |   0.0 |  0.08
Output  | 0.0001642  | 0.0001642  | 0.0001642  |   0.0 |  0.00
Modify  | 0.36396    | 0.36396    | 0.36396    |   0.0 |  0.35
Other   |            | 0.05795    |            |       |  0.06

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

Total # of neighbors = 118950
Ave neighs/atom = 59.475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.507617952929, Press = -219.097696574987
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -10432.359     -10432.359     -10516.738     -10516.738      326.55683      326.55683      28074.254      28074.254     -771.68088     -771.68088    
      6000  -10432.961     -10432.961     -10514.663     -10514.663      316.19481      316.19481      28065.023      28065.023     -275.66876     -275.66876    
Loop time of 102.135 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.846 ns/day, 28.371 hours/ns, 9.791 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.62     | 101.62     | 101.62     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081624   | 0.081624   | 0.081624   |   0.0 |  0.08
Output  | 0.00016652 | 0.00016652 | 0.00016652 |   0.0 |  0.00
Modify  | 0.38107    | 0.38107    | 0.38107    |   0.0 |  0.37
Other   |            | 0.05703    |            |       |  0.06

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

Total # of neighbors = 118918
Ave neighs/atom = 59.459
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.238335969684, Press = -55.5670294681686
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -10432.961     -10432.961     -10514.663     -10514.663      316.19481      316.19481      28065.023      28065.023     -275.66876     -275.66876    
      7000  -10434.011     -10434.011     -10509.44      -10509.44       291.91776      291.91776      28011.385      28011.385      2626.3211      2626.3211    
Loop time of 103.608 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.780 hours/ns, 9.652 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.07     | 103.07     | 103.07     |   0.0 | 99.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082434   | 0.082434   | 0.082434   |   0.0 |  0.08
Output  | 0.00017853 | 0.00017853 | 0.00017853 |   0.0 |  0.00
Modify  | 0.39208    | 0.39208    | 0.39208    |   0.0 |  0.38
Other   |            | 0.0589     |            |       |  0.06

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

Total # of neighbors = 118914
Ave neighs/atom = 59.457
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 311.72459399535, Press = -30.1285305312423
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.703 | 3.703 | 3.703 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -10434.011     -10434.011     -10509.44      -10509.44       291.91776      291.91776      28011.385      28011.385      2626.3211      2626.3211    
      8000  -10434.373     -10434.373     -10512.548     -10512.548      302.54442      302.54442      28020.179      28020.179      1804.1572      1804.1572    
Loop time of 105.306 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.252 hours/ns, 9.496 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    | 104.77     | 104.77     | 104.77     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084227   | 0.084227   | 0.084227   |   0.0 |  0.08
Output  | 0.00016406 | 0.00016406 | 0.00016406 |   0.0 |  0.00
Modify  | 0.39503    | 0.39503    | 0.39503    |   0.0 |  0.38
Other   |            | 0.05836    |            |       |  0.06

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

Total # of neighbors = 119170
Ave neighs/atom = 59.585
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.361924216744, Press = 3.43682204357952
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -10434.373     -10434.373     -10512.548     -10512.548      302.54442      302.54442      28020.179      28020.179      1804.1572      1804.1572    
      9000  -10433.756     -10433.756     -10512.619     -10512.619      305.20711      305.20711      28040.139      28040.139      1129.0541      1129.0541    
Loop time of 103.631 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.787 hours/ns, 9.650 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.1      | 103.1      | 103.1      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081669   | 0.081669   | 0.081669   |   0.0 |  0.08
Output  | 0.00016519 | 0.00016519 | 0.00016519 |   0.0 |  0.00
Modify  | 0.38807    | 0.38807    | 0.38807    |   0.0 |  0.37
Other   |            | 0.0585     |            |       |  0.06

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

Total # of neighbors = 119176
Ave neighs/atom = 59.588
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.694554689751, Press = 6.87709312840842
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -10433.756     -10433.756     -10512.619     -10512.619      305.20711      305.20711      28040.139      28040.139      1129.0541      1129.0541    
     10000  -10430.123     -10430.123     -10511.723     -10511.723      315.79966      315.79966      28056.976      28056.976      293.20793      293.20793    
Loop time of 104.166 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.935 hours/ns, 9.600 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.63     | 103.63     | 103.63     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083406   | 0.083406   | 0.083406   |   0.0 |  0.08
Output  | 0.0001657  | 0.0001657  | 0.0001657  |   0.0 |  0.00
Modify  | 0.39265    | 0.39265    | 0.39265    |   0.0 |  0.38
Other   |            | 0.05855    |            |       |  0.06

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

Total # of neighbors = 119024
Ave neighs/atom = 59.512
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.830492951018, Press = 7.44855950724131
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -10430.123     -10430.123     -10511.723     -10511.723      315.79966      315.79966      28056.976      28056.976      293.20793      293.20793    
     11000  -10434.517     -10434.517     -10514.856     -10514.856      310.9198       310.9198       28068.982      28068.982     -823.08698     -823.08698    
Loop time of 104.542 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.039 hours/ns, 9.566 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    | 104.01     | 104.01     | 104.01     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082147   | 0.082147   | 0.082147   |   0.0 |  0.08
Output  | 0.00016512 | 0.00016512 | 0.00016512 |   0.0 |  0.00
Modify  | 0.39317    | 0.39317    | 0.39317    |   0.0 |  0.38
Other   |            | 0.05845    |            |       |  0.06

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

Total # of neighbors = 118956
Ave neighs/atom = 59.478
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.215508209404, Press = 5.20560208059489
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -10434.517     -10434.517     -10514.856     -10514.856      310.9198       310.9198       28068.982      28068.982     -823.08698     -823.08698    
     12000  -10430.286     -10430.286     -10511.131     -10511.131      312.87933      312.87933      28083.542      28083.542     -1129.1846     -1129.1846    
Loop time of 104.263 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.962 hours/ns, 9.591 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.73     | 103.73     | 103.73     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081984   | 0.081984   | 0.081984   |   0.0 |  0.08
Output  | 0.00016564 | 0.00016564 | 0.00016564 |   0.0 |  0.00
Modify  | 0.38896    | 0.38896    | 0.38896    |   0.0 |  0.37
Other   |            | 0.0581     |            |       |  0.06

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

Total # of neighbors = 118990
Ave neighs/atom = 59.495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.560519525553, Press = 2.87619586645743
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -10430.286     -10430.286     -10511.131     -10511.131      312.87933      312.87933      28083.542      28083.542     -1129.1846     -1129.1846    
     13000  -10432.251     -10432.251     -10515.586     -10515.586      322.51796      322.51796      28078.597      28078.597     -1378.353      -1378.353     
Loop time of 105.682 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.356 hours/ns, 9.462 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.14     | 105.14     | 105.14     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082687   | 0.082687   | 0.082687   |   0.0 |  0.08
Output  | 0.00016413 | 0.00016413 | 0.00016413 |   0.0 |  0.00
Modify  | 0.39655    | 0.39655    | 0.39655    |   0.0 |  0.38
Other   |            | 0.05902    |            |       |  0.06

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

Total # of neighbors = 119018
Ave neighs/atom = 59.509
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.410614210507, Press = -1.09559207925453
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -10432.251     -10432.251     -10515.586     -10515.586      322.51796      322.51796      28078.597      28078.597     -1378.353      -1378.353     
     14000  -10435.074     -10435.074     -10513.584     -10513.584      303.84515      303.84515      28063.649      28063.649     -485.09575     -485.09575    
Loop time of 103.87 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.853 hours/ns, 9.627 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.34     | 103.34     | 103.34     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081323   | 0.081323   | 0.081323   |   0.0 |  0.08
Output  | 0.00038848 | 0.00038848 | 0.00038848 |   0.0 |  0.00
Modify  | 0.389      | 0.389      | 0.389      |   0.0 |  0.37
Other   |            | 0.05845    |            |       |  0.06

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

Total # of neighbors = 119002
Ave neighs/atom = 59.501
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.570398233643, Press = -5.45046137014732
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -10435.074     -10435.074     -10513.584     -10513.584      303.84515      303.84515      28063.649      28063.649     -485.09575     -485.09575    
     15000  -10431.358     -10431.358     -10512.985     -10512.985      315.90454      315.90454      28029.434      28029.434      1494.1677      1494.1677    
Loop time of 104.718 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.088 hours/ns, 9.549 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    | 104.19     | 104.19     | 104.19     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081594   | 0.081594   | 0.081594   |   0.0 |  0.08
Output  | 0.00016477 | 0.00016477 | 0.00016477 |   0.0 |  0.00
Modify  | 0.38959    | 0.38959    | 0.38959    |   0.0 |  0.37
Other   |            | 0.05857    |            |       |  0.06

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

Total # of neighbors = 119080
Ave neighs/atom = 59.54
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.40774601784, Press = -5.35426945296209
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -10431.358     -10431.358     -10512.985     -10512.985      315.90454      315.90454      28029.434      28029.434      1494.1677      1494.1677    
     16000  -10436.055     -10436.055     -10517.799     -10517.799      316.35832      316.35832      28016.391      28016.391      1896.1967      1896.1967    
Loop time of 104.935 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.149 hours/ns, 9.530 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.4      | 104.4      | 104.4      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082947   | 0.082947   | 0.082947   |   0.0 |  0.08
Output  | 0.00016528 | 0.00016528 | 0.00016528 |   0.0 |  0.00
Modify  | 0.39473    | 0.39473    | 0.39473    |   0.0 |  0.38
Other   |            | 0.05913    |            |       |  0.06

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

Total # of neighbors = 119150
Ave neighs/atom = 59.575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.364291319773, Press = -0.305057373389543
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -10436.055     -10436.055     -10517.799     -10517.799      316.35832      316.35832      28016.391      28016.391      1896.1967      1896.1967    
     17000  -10432.829     -10432.829     -10516.406     -10516.406      323.45188      323.45188      28032.5        28032.5        1213.7939      1213.7939    
Loop time of 104.706 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.085 hours/ns, 9.551 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    | 104.17     | 104.17     | 104.17     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082043   | 0.082043   | 0.082043   |   0.0 |  0.08
Output  | 0.00016509 | 0.00016509 | 0.00016509 |   0.0 |  0.00
Modify  | 0.39358    | 0.39358    | 0.39358    |   0.0 |  0.38
Other   |            | 0.05812    |            |       |  0.06

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

Total # of neighbors = 119024
Ave neighs/atom = 59.512
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.265108089281, Press = 2.1348384507134
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -10432.829     -10432.829     -10516.406     -10516.406      323.45188      323.45188      28032.5        28032.5        1213.7939      1213.7939    
     18000  -10437.363     -10437.363     -10517.071     -10517.071      308.4777       308.4777       28042.4        28042.4        596.60579      596.60579    
Loop time of 103.038 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.622 hours/ns, 9.705 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    | 102.51     | 102.51     | 102.51     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080992   | 0.080992   | 0.080992   |   0.0 |  0.08
Output  | 0.00016631 | 0.00016631 | 0.00016631 |   0.0 |  0.00
Modify  | 0.3864     | 0.3864     | 0.3864     |   0.0 |  0.38
Other   |            | 0.05825    |            |       |  0.06

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

Total # of neighbors = 119056
Ave neighs/atom = 59.528
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.141812765207, Press = 2.70336165592209
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -10437.363     -10437.363     -10517.071     -10517.071      308.4777       308.4777       28042.4        28042.4        596.60579      596.60579    
     19000  -10433.252     -10433.252     -10514.837     -10514.837      315.74117      315.74117      28059.337      28059.337     -64.636995     -64.636995    
Loop time of 105.34 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.261 hours/ns, 9.493 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    | 104.8      | 104.8      | 104.8      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082732   | 0.082732   | 0.082732   |   0.0 |  0.08
Output  | 0.0001653  | 0.0001653  | 0.0001653  |   0.0 |  0.00
Modify  | 0.39622    | 0.39622    | 0.39622    |   0.0 |  0.38
Other   |            | 0.05856    |            |       |  0.06

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

Total # of neighbors = 118988
Ave neighs/atom = 59.494
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.063454456129, Press = 1.9625164993898
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -10433.252     -10433.252     -10514.837     -10514.837      315.74117      315.74117      28059.337      28059.337     -64.636995     -64.636995    
     20000  -10438.481     -10438.481     -10517.019     -10517.019      303.94771      303.94771      28059.965      28059.965     -538.54435     -538.54435    
Loop time of 104.208 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.947 hours/ns, 9.596 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.67     | 103.67     | 103.67     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082745   | 0.082745   | 0.082745   |   0.0 |  0.08
Output  | 0.00017394 | 0.00017394 | 0.00017394 |   0.0 |  0.00
Modify  | 0.39211    | 0.39211    | 0.39211    |   0.0 |  0.38
Other   |            | 0.05891    |            |       |  0.06

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

Total # of neighbors = 119020
Ave neighs/atom = 59.51
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.877113201494, Press = 0.486986682860308
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -10438.481     -10438.481     -10517.019     -10517.019      303.94771      303.94771      28059.965      28059.965     -538.54435     -538.54435    
     21000  -10433.857     -10433.857     -10513.932     -10513.932      309.90056      309.90056      28070.011      28070.011     -549.98017     -549.98017    
Loop time of 105.494 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.304 hours/ns, 9.479 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    | 104.95     | 104.95     | 104.95     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08324    | 0.08324    | 0.08324    |   0.0 |  0.08
Output  | 0.00020683 | 0.00020683 | 0.00020683 |   0.0 |  0.00
Modify  | 0.39824    | 0.39824    | 0.39824    |   0.0 |  0.38
Other   |            | 0.05916    |            |       |  0.06

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

Total # of neighbors = 119016
Ave neighs/atom = 59.508
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.872935873019, Press = -1.23347329872056
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -10433.857     -10433.857     -10513.932     -10513.932      309.90056      309.90056      28070.011      28070.011     -549.98017     -549.98017    
     22000  -10432.732     -10432.732     -10516.297     -10516.297      323.40363      323.40363      28070.734      28070.734     -808.74914     -808.74914    
Loop time of 101.883 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.848 ns/day, 28.301 hours/ns, 9.815 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.37     | 101.37     | 101.37     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080805   | 0.080805   | 0.080805   |   0.0 |  0.08
Output  | 0.0001655  | 0.0001655  | 0.0001655  |   0.0 |  0.00
Modify  | 0.37902    | 0.37902    | 0.37902    |   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:           3147 ave        3147 max        3147 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:       119020 ave      119020 max      119020 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119020
Ave neighs/atom = 59.51
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.782138017254, Press = -3.60269998659792
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -10432.732     -10432.732     -10516.297     -10516.297      323.40363      323.40363      28070.734      28070.734     -808.74914     -808.74914    
     23000  -10433.062     -10433.062     -10512.749     -10512.749      308.3943       308.3943       28030.055      28030.055      1690.6283      1690.6283    
Loop time of 105.951 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.431 hours/ns, 9.438 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.41     | 105.41     | 105.41     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08259    | 0.08259    | 0.08259    |   0.0 |  0.08
Output  | 0.00016547 | 0.00016547 | 0.00016547 |   0.0 |  0.00
Modify  | 0.39983    | 0.39983    | 0.39983    |   0.0 |  0.38
Other   |            | 0.05921    |            |       |  0.06

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

Total # of neighbors = 118968
Ave neighs/atom = 59.484
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.72358360648, Press = -4.1450186425169
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -10433.062     -10433.062     -10512.749     -10512.749      308.3943       308.3943       28030.055      28030.055      1690.6283      1690.6283    
     24000  -10433.564     -10433.564     -10514.36      -10514.36       312.68702      312.68702      28023.01       28023.01       1870.2911      1870.2911    
Loop time of 105.696 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.360 hours/ns, 9.461 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.16     | 105.16     | 105.16     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082103   | 0.082103   | 0.082103   |   0.0 |  0.08
Output  | 0.00016677 | 0.00016677 | 0.00016677 |   0.0 |  0.00
Modify  | 0.39875    | 0.39875    | 0.39875    |   0.0 |  0.38
Other   |            | 0.05917    |            |       |  0.06

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

Total # of neighbors = 119070
Ave neighs/atom = 59.535
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.738083930452, Press = -0.577114979786561
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -10433.564     -10433.564     -10514.36      -10514.36       312.68702      312.68702      28023.01       28023.01       1870.2911      1870.2911    
     25000  -10431.582     -10431.582     -10513.538     -10513.538      317.17997      317.17997      28037.088      28037.088      1376.5711      1376.5711    
Loop time of 104.878 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.133 hours/ns, 9.535 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    | 104.34     | 104.34     | 104.34     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081947   | 0.081947   | 0.081947   |   0.0 |  0.08
Output  | 0.00016358 | 0.00016358 | 0.00016358 |   0.0 |  0.00
Modify  | 0.39454    | 0.39454    | 0.39454    |   0.0 |  0.38
Other   |            | 0.05846    |            |       |  0.06

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

Total # of neighbors = 119132
Ave neighs/atom = 59.566
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.879343835625, Press = 0.660877385336263
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -10431.582     -10431.582     -10513.538     -10513.538      317.17997      317.17997      28037.088      28037.088      1376.5711      1376.5711    
     26000  -10434.803     -10434.803     -10517.217     -10517.217      318.953        318.953        28042.318      28042.318      759.82728      759.82728    
Loop time of 105.857 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.816 ns/day, 29.405 hours/ns, 9.447 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.31     | 105.31     | 105.31     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082957   | 0.082957   | 0.082957   |   0.0 |  0.08
Output  | 0.00016384 | 0.00016384 | 0.00016384 |   0.0 |  0.00
Modify  | 0.40155    | 0.40155    | 0.40155    |   0.0 |  0.38
Other   |            | 0.05922    |            |       |  0.06

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

Total # of neighbors = 119096
Ave neighs/atom = 59.548
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.911002222768, Press = 1.83635948137116
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -10434.803     -10434.803     -10517.217     -10517.217      318.953        318.953        28042.318      28042.318      759.82728      759.82728    
     27000  -10432.472     -10432.472     -10516.168     -10516.168      323.91439      323.91439      28071.101      28071.101     -847.93853     -847.93853    
Loop time of 104.474 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.021 hours/ns, 9.572 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.94     | 103.94     | 103.94     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082519   | 0.082519   | 0.082519   |   0.0 |  0.08
Output  | 0.00019145 | 0.00019145 | 0.00019145 |   0.0 |  0.00
Modify  | 0.39507    | 0.39507    | 0.39507    |   0.0 |  0.38
Other   |            | 0.05816    |            |       |  0.06

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

Total # of neighbors = 119016
Ave neighs/atom = 59.508
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.776930488417, Press = 2.5957571497013
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -10432.472     -10432.472     -10516.168     -10516.168      323.91439      323.91439      28071.101      28071.101     -847.93853     -847.93853    
     28000  -10436.889     -10436.889     -10513.549     -10513.549      296.68105      296.68105      28116.283      28116.283     -3365.2783     -3365.2783    
Loop time of 103.986 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.885 hours/ns, 9.617 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.46     | 103.46     | 103.46     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082746   | 0.082746   | 0.082746   |   0.0 |  0.08
Output  | 0.0001656  | 0.0001656  | 0.0001656  |   0.0 |  0.00
Modify  | 0.38974    | 0.38974    | 0.38974    |   0.0 |  0.37
Other   |            | 0.05845    |            |       |  0.06

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

Total # of neighbors = 118910
Ave neighs/atom = 59.455
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.744975983001, Press = 1.56580520759188
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -10436.889     -10436.889     -10513.549     -10513.549      296.68105      296.68105      28116.283      28116.283     -3365.2783     -3365.2783    
     29000  -10432.109     -10432.109     -10514.364     -10514.364      318.33757      318.33757      28109.744      28109.744     -2785.6871     -2785.6871    
Loop time of 105.457 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.294 hours/ns, 9.483 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    | 104.92     | 104.92     | 104.92     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082784   | 0.082784   | 0.082784   |   0.0 |  0.08
Output  | 0.00017069 | 0.00017069 | 0.00017069 |   0.0 |  0.00
Modify  | 0.39839    | 0.39839    | 0.39839    |   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:           3128 ave        3128 max        3128 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:       118902 ave      118902 max      118902 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118902
Ave neighs/atom = 59.451
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.833459199731, Press = -0.73178770411378
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -10432.109     -10432.109     -10514.364     -10514.364      318.33757      318.33757      28109.744      28109.744     -2785.6871     -2785.6871    
     30000  -10436.313     -10436.313     -10517.614     -10517.614      314.64447      314.64447      28068.029      28068.029     -872.44979     -872.44979    
Loop time of 104.594 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.054 hours/ns, 9.561 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    | 104.06     | 104.06     | 104.06     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081939   | 0.081939   | 0.081939   |   0.0 |  0.08
Output  | 0.00016429 | 0.00016429 | 0.00016429 |   0.0 |  0.00
Modify  | 0.39351    | 0.39351    | 0.39351    |   0.0 |  0.38
Other   |            | 0.0594     |            |       |  0.06

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

Total # of neighbors = 118866
Ave neighs/atom = 59.433
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.824255519013, Press = -1.32691993119724
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -10436.313     -10436.313     -10517.614     -10517.614      314.64447      314.64447      28068.029      28068.029     -872.44979     -872.44979    
     31000  -10433.199     -10433.199     -10514.669     -10514.669      315.29815      315.29815      28050.029      28050.029      381.85425      381.85425    
Loop time of 105.38 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.272 hours/ns, 9.490 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    | 104.84     | 104.84     | 104.84     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08227    | 0.08227    | 0.08227    |   0.0 |  0.08
Output  | 0.00016414 | 0.00016414 | 0.00016414 |   0.0 |  0.00
Modify  | 0.3952     | 0.3952     | 0.3952     |   0.0 |  0.38
Other   |            | 0.05886    |            |       |  0.06

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

Total # of neighbors = 118942
Ave neighs/atom = 59.471
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.768215559566, Press = -1.0200477869703
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -10433.199     -10433.199     -10514.669     -10514.669      315.29815      315.29815      28050.029      28050.029      381.85425      381.85425    
     32000  -10437.932     -10437.932     -10516.66      -10516.66       304.68583      304.68583      28022.708      28022.708      1617.478       1617.478     
Loop time of 105.459 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.294 hours/ns, 9.482 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    | 104.92     | 104.92     | 104.92     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081612   | 0.081612   | 0.081612   |   0.0 |  0.08
Output  | 0.00016541 | 0.00016541 | 0.00016541 |   0.0 |  0.00
Modify  | 0.39642    | 0.39642    | 0.39642    |   0.0 |  0.38
Other   |            | 0.05874    |            |       |  0.06

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

Total # of neighbors = 119014
Ave neighs/atom = 59.507
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.728793303932, Press = -0.206823984029636
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -10437.932     -10437.932     -10516.66      -10516.66       304.68583      304.68583      28022.708      28022.708      1617.478       1617.478     
     33000  -10432.852     -10432.852     -10512.608     -10512.608      308.66328      308.66328      27978.125      27978.125      4458.2111      4458.2111    
Loop time of 104.877 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.133 hours/ns, 9.535 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    | 104.34     | 104.34     | 104.34     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082341   | 0.082341   | 0.082341   |   0.0 |  0.08
Output  | 0.00016546 | 0.00016546 | 0.00016546 |   0.0 |  0.00
Modify  | 0.39515    | 0.39515    | 0.39515    |   0.0 |  0.38
Other   |            | 0.05881    |            |       |  0.06

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

Total # of neighbors = 118970
Ave neighs/atom = 59.485
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.658635720195, Press = 1.90405665967669
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -10432.852     -10432.852     -10512.608     -10512.608      308.66328      308.66328      27978.125      27978.125      4458.2111      4458.2111    
     34000  -10437.95      -10437.95      -10515.557     -10515.557      300.34835      300.34835      28012.156      28012.156      2105.807       2105.807     
Loop time of 105.569 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.325 hours/ns, 9.472 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.03     | 105.03     | 105.03     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083479   | 0.083479   | 0.083479   |   0.0 |  0.08
Output  | 0.00016543 | 0.00016543 | 0.00016543 |   0.0 |  0.00
Modify  | 0.39859    | 0.39859    | 0.39859    |   0.0 |  0.38
Other   |            | 0.05876    |            |       |  0.06

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

Total # of neighbors = 119162
Ave neighs/atom = 59.581
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.605084203703, Press = 3.58683170474674
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -10437.95      -10437.95      -10515.557     -10515.557      300.34835      300.34835      28012.156      28012.156      2105.807       2105.807     
     35000  -10432.953     -10432.953     -10514.21      -10514.21       314.47083      314.47083      28070.034      28070.034     -605.66985     -605.66985    
Loop time of 105.471 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.819 ns/day, 29.298 hours/ns, 9.481 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    | 104.93     | 104.93     | 104.93     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082336   | 0.082336   | 0.082336   |   0.0 |  0.08
Output  | 0.00016414 | 0.00016414 | 0.00016414 |   0.0 |  0.00
Modify  | 0.40015    | 0.40015    | 0.40015    |   0.0 |  0.38
Other   |            | 0.05939    |            |       |  0.06

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

Total # of neighbors = 119172
Ave neighs/atom = 59.586
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.595814726564, Press = 2.14837691938335
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -10432.953     -10432.953     -10514.21      -10514.21       314.47083      314.47083      28070.034      28070.034     -605.66985     -605.66985    
     36000  -10432.797     -10432.797     -10514.964     -10514.964      317.99455      317.99455      28084.447      28084.447     -1469.9173     -1469.9173    
Loop time of 105.333 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.259 hours/ns, 9.494 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    | 104.79     | 104.79     | 104.79     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082903   | 0.082903   | 0.082903   |   0.0 |  0.08
Output  | 0.00019613 | 0.00019613 | 0.00019613 |   0.0 |  0.00
Modify  | 0.39649    | 0.39649    | 0.39649    |   0.0 |  0.38
Other   |            | 0.05897    |            |       |  0.06

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

Total # of neighbors = 118996
Ave neighs/atom = 59.498
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.541768810757, Press = 1.01093623579225
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -10432.797     -10432.797     -10514.964     -10514.964      317.99455      317.99455      28084.447      28084.447     -1469.9173     -1469.9173    
     37000  -10431.513     -10431.513     -10515.389     -10515.389      324.60932      324.60932      28081.952      28081.952     -1495.8332     -1495.8332    
Loop time of 105.579 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.328 hours/ns, 9.472 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.04     | 105.04     | 105.04     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081436   | 0.081436   | 0.081436   |   0.0 |  0.08
Output  | 0.00016773 | 0.00016773 | 0.00016773 |   0.0 |  0.00
Modify  | 0.3961     | 0.3961     | 0.3961     |   0.0 |  0.38
Other   |            | 0.05856    |            |       |  0.06

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

Total # of neighbors = 119018
Ave neighs/atom = 59.509
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.502473686916, Press = -0.0121241495116133
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -10431.513     -10431.513     -10515.389     -10515.389      324.60932      324.60932      28081.952      28081.952     -1495.8332     -1495.8332    
     38000  -10436.534     -10436.534     -10515         -10515          303.66888      303.66888      28064.538      28064.538     -589.42856     -589.42856    
Loop time of 105.403 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.279 hours/ns, 9.487 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    | 104.87     | 104.87     | 104.87     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082734   | 0.082734   | 0.082734   |   0.0 |  0.08
Output  | 0.00016957 | 0.00016957 | 0.00016957 |   0.0 |  0.00
Modify  | 0.39422    | 0.39422    | 0.39422    |   0.0 |  0.37
Other   |            | 0.05843    |            |       |  0.06

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

Total # of neighbors = 118880
Ave neighs/atom = 59.44
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.454430989754, Press = -1.00243481675355
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -10436.534     -10436.534     -10515         -10515          303.66888      303.66888      28064.538      28064.538     -589.42856     -589.42856    
     39000  -10434.743     -10434.743     -10516.719     -10516.719      317.25423      317.25423      28020.312      28020.312      1877.2015      1877.2015    
Loop time of 102.593 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.842 ns/day, 28.498 hours/ns, 9.747 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    | 102.07     | 102.07     | 102.07     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081568   | 0.081568   | 0.081568   |   0.0 |  0.08
Output  | 0.00016336 | 0.00016336 | 0.00016336 |   0.0 |  0.00
Modify  | 0.38167    | 0.38167    | 0.38167    |   0.0 |  0.37
Other   |            | 0.05804    |            |       |  0.06

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

Total # of neighbors = 118986
Ave neighs/atom = 59.493
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.476344451249, Press = -2.02240326314838
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -10434.743     -10434.743     -10516.719     -10516.719      317.25423      317.25423      28020.312      28020.312      1877.2015      1877.2015    
     40000  -10435.493     -10435.493     -10515.482     -10515.482      309.56617      309.56617      28000.583      28000.583      2964.802       2964.802     
Loop time of 105.039 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.177 hours/ns, 9.520 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    | 104.5      | 104.5      | 104.5      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083217   | 0.083217   | 0.083217   |   0.0 |  0.08
Output  | 0.00016406 | 0.00016406 | 0.00016406 |   0.0 |  0.00
Modify  | 0.39675    | 0.39675    | 0.39675    |   0.0 |  0.38
Other   |            | 0.05849    |            |       |  0.06

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

Total # of neighbors = 119096
Ave neighs/atom = 59.548
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.512407672385, Press = -0.237364002320356
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -10435.493     -10435.493     -10515.482     -10515.482      309.56617      309.56617      28000.583      28000.583      2964.802       2964.802     
     41000  -10432.701     -10432.701     -10513.782     -10513.782      313.79077      313.79077      28021.277      28021.277      2084.6602      2084.6602    
Loop time of 104.798 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.111 hours/ns, 9.542 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    | 104.27     | 104.27     | 104.27     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083449   | 0.083449   | 0.083449   |   0.0 |  0.08
Output  | 0.0002447  | 0.0002447  | 0.0002447  |   0.0 |  0.00
Modify  | 0.39099    | 0.39099    | 0.39099    |   0.0 |  0.37
Other   |            | 0.05812    |            |       |  0.06

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

Total # of neighbors = 119060
Ave neighs/atom = 59.53
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.463860985406, Press = 0.931063478918886
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -10432.701     -10432.701     -10513.782     -10513.782      313.79077      313.79077      28021.277      28021.277      2084.6602      2084.6602    
     42000  -10437.834     -10437.834     -10516.115     -10516.115      302.95612      302.95612      28029.645      28029.645      1447.2568      1447.2568    
Loop time of 103.782 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.828 hours/ns, 9.636 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.25     | 103.25     | 103.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08217    | 0.08217    | 0.08217    |   0.0 |  0.08
Output  | 0.00025874 | 0.00025874 | 0.00025874 |   0.0 |  0.00
Modify  | 0.38893    | 0.38893    | 0.38893    |   0.0 |  0.37
Other   |            | 0.05825    |            |       |  0.06

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

Total # of neighbors = 119204
Ave neighs/atom = 59.602
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.429337076557, Press = 1.62201461752172
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -10437.834     -10437.834     -10516.115     -10516.115      302.95612      302.95612      28029.645      28029.645      1447.2568      1447.2568    
     43000  -10433.299     -10433.299     -10514.12      -10514.12       312.78384      312.78384      28059.568      28059.568      23.947039      23.947039    
Loop time of 103.533 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.835 ns/day, 28.759 hours/ns, 9.659 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.01     | 103.01     | 103.01     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082287   | 0.082287   | 0.082287   |   0.0 |  0.08
Output  | 0.00016484 | 0.00016484 | 0.00016484 |   0.0 |  0.00
Modify  | 0.38541    | 0.38541    | 0.38541    |   0.0 |  0.37
Other   |            | 0.05815    |            |       |  0.06

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

Total # of neighbors = 119088
Ave neighs/atom = 59.544
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.443266120889, Press = 1.84201919583962
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -10433.299     -10433.299     -10514.12      -10514.12       312.78384      312.78384      28059.568      28059.568      23.947039      23.947039    
     44000  -10432.924     -10432.924     -10516.258     -10516.258      322.51027      322.51027      28094.732      28094.732     -2178.011      -2178.011     
Loop time of 104.786 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.107 hours/ns, 9.543 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.26     | 104.26     | 104.26     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08203    | 0.08203    | 0.08203    |   0.0 |  0.08
Output  | 0.00016496 | 0.00016496 | 0.00016496 |   0.0 |  0.00
Modify  | 0.38957    | 0.38957    | 0.38957    |   0.0 |  0.37
Other   |            | 0.05828    |            |       |  0.06

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

Total # of neighbors = 119048
Ave neighs/atom = 59.524
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.471845578546, Press = 1.29296513182387
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -10432.924     -10432.924     -10516.258     -10516.258      322.51027      322.51027      28094.732      28094.732     -2178.011      -2178.011     
     45000  -10429.691     -10429.691     -10513.007     -10513.007      322.4415       322.4415       28126.008      28126.008     -3468.9742     -3468.9742    
Loop time of 103.291 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.692 hours/ns, 9.681 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    | 102.77     | 102.77     | 102.77     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08115    | 0.08115    | 0.08115    |   0.0 |  0.08
Output  | 0.00017094 | 0.00017094 | 0.00017094 |   0.0 |  0.00
Modify  | 0.38405    | 0.38405    | 0.38405    |   0.0 |  0.37
Other   |            | 0.05784    |            |       |  0.06

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

Total # of neighbors = 118930
Ave neighs/atom = 59.465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.512369450933, Press = 0.202392016965694
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -10429.691     -10429.691     -10513.007     -10513.007      322.4415       322.4415       28126.008      28126.008     -3468.9742     -3468.9742    
     46000  -10431.991     -10431.991     -10513.247     -10513.247      314.46874      314.46874      28095.858      28095.858     -1907.1542     -1907.1542    
Loop time of 104.004 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.890 hours/ns, 9.615 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.47     | 103.47     | 103.47     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081573   | 0.081573   | 0.081573   |   0.0 |  0.08
Output  | 0.00017142 | 0.00017142 | 0.00017142 |   0.0 |  0.00
Modify  | 0.39117    | 0.39117    | 0.39117    |   0.0 |  0.38
Other   |            | 0.05832    |            |       |  0.06

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

Total # of neighbors = 118852
Ave neighs/atom = 59.426
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.566562195911, Press = -0.735724816684842
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -10431.991     -10431.991     -10513.247     -10513.247      314.46874      314.46874      28095.858      28095.858     -1907.1542     -1907.1542    
     47000  -10436.243     -10436.243     -10516.192     -10516.192      309.40773      309.40773      28051.256      28051.256      236.23878      236.23878    
Loop time of 106.188 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.814 ns/day, 29.497 hours/ns, 9.417 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.64     | 105.64     | 105.64     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.084018   | 0.084018   | 0.084018   |   0.0 |  0.08
Output  | 0.00016452 | 0.00016452 | 0.00016452 |   0.0 |  0.00
Modify  | 0.4033     | 0.4033     | 0.4033     |   0.0 |  0.38
Other   |            | 0.05888    |            |       |  0.06

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

Total # of neighbors = 118952
Ave neighs/atom = 59.476
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.520437277122, Press = -0.538880841026706
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -10436.243     -10436.243     -10516.192     -10516.192      309.40773      309.40773      28051.256      28051.256      236.23878      236.23878    
     48000  -10433.245     -10433.245     -10513.644     -10513.644      311.15069      311.15069      28035.755      28035.755      1215.5036      1215.5036    
Loop time of 105.829 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.29     | 105.29     | 105.29     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082384   | 0.082384   | 0.082384   |   0.0 |  0.08
Output  | 0.00016453 | 0.00016453 | 0.00016453 |   0.0 |  0.00
Modify  | 0.40071    | 0.40071    | 0.40071    |   0.0 |  0.38
Other   |            | 0.05944    |            |       |  0.06

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

Total # of neighbors = 118940
Ave neighs/atom = 59.47
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.508476188469, Press = 0.112244474512046
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -10433.245     -10433.245     -10513.644     -10513.644      311.15069      311.15069      28035.755      28035.755      1215.5036      1215.5036    
     49000  -10434.094     -10434.094     -10514.325     -10514.325      310.50289      310.50289      28035.953      28035.953      1078.1285      1078.1285    
Loop time of 105.652 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.348 hours/ns, 9.465 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.11     | 105.11     | 105.11     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083014   | 0.083014   | 0.083014   |   0.0 |  0.08
Output  | 0.00016309 | 0.00016309 | 0.00016309 |   0.0 |  0.00
Modify  | 0.39791    | 0.39791    | 0.39791    |   0.0 |  0.38
Other   |            | 0.05871    |            |       |  0.06

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

Total # of neighbors = 119022
Ave neighs/atom = 59.511
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.525534551897, Press = 0.745893702199952
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -10434.094     -10434.094     -10514.325     -10514.325      310.50289      310.50289      28035.953      28035.953      1078.1285      1078.1285    
     50000  -10432.085     -10432.085     -10512.689     -10512.689      311.94431      311.94431      28034.874      28034.874      1196.0683      1196.0683    
Loop time of 105.417 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.282 hours/ns, 9.486 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    | 104.88     | 104.88     | 104.88     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082647   | 0.082647   | 0.082647   |   0.0 |  0.08
Output  | 0.00016484 | 0.00016484 | 0.00016484 |   0.0 |  0.00
Modify  | 0.39645    | 0.39645    | 0.39645    |   0.0 |  0.38
Other   |            | 0.05885    |            |       |  0.06

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

Total # of neighbors = 119128
Ave neighs/atom = 59.564
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.562500495009, Press = 1.6797343992225
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -10432.085     -10432.085     -10512.689     -10512.689      311.94431      311.94431      28034.874      28034.874      1196.0683      1196.0683    
     51000  -10431.288     -10431.288     -10514.91      -10514.91       323.62617      323.62617      28070.15       28070.15      -753.57636     -753.57636    
Loop time of 107.612 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.803 ns/day, 29.892 hours/ns, 9.293 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    | 107.06     | 107.06     | 107.06     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.083869   | 0.083869   | 0.083869   |   0.0 |  0.08
Output  | 0.00024548 | 0.00024548 | 0.00024548 |   0.0 |  0.00
Modify  | 0.40663    | 0.40663    | 0.40663    |   0.0 |  0.38
Other   |            | 0.05988    |            |       |  0.06

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

Total # of neighbors = 119092
Ave neighs/atom = 59.546
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.649193870696, Press = 2.34007491296595
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -10431.288     -10431.288     -10514.91      -10514.91       323.62617      323.62617      28070.15       28070.15      -753.57636     -753.57636    
     52000  -10432.804     -10432.804     -10514.435     -10514.435      315.91926      315.91926      28090.951      28090.951     -1868.292      -1868.292     
Loop time of 103.1 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.838 ns/day, 28.639 hours/ns, 9.699 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    | 102.57     | 102.57     | 102.57     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082226   | 0.082226   | 0.082226   |   0.0 |  0.08
Output  | 0.00039743 | 0.00039743 | 0.00039743 |   0.0 |  0.00
Modify  | 0.38518    | 0.38518    | 0.38518    |   0.0 |  0.37
Other   |            | 0.05843    |            |       |  0.06

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

Total # of neighbors = 118972
Ave neighs/atom = 59.486
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.664995294792, Press = 1.12506705059477
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -10432.804     -10432.804     -10514.435     -10514.435      315.91926      315.91926      28090.951      28090.951     -1868.292      -1868.292     
     53000  -10438.186     -10438.186     -10517.995     -10517.995      308.86837      308.86837      28070.349      28070.349     -1197.3817     -1197.3817    
Loop time of 103.149 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.838 ns/day, 28.652 hours/ns, 9.695 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    | 102.62     | 102.62     | 102.62     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082317   | 0.082317   | 0.082317   |   0.0 |  0.08
Output  | 0.00019883 | 0.00019883 | 0.00019883 |   0.0 |  0.00
Modify  | 0.3864     | 0.3864     | 0.3864     |   0.0 |  0.37
Other   |            | 0.05806    |            |       |  0.06

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

Total # of neighbors = 118910
Ave neighs/atom = 59.455
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.662107591169, Press = 0.308489697220202
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -10438.186     -10438.186     -10517.995     -10517.995      308.86837      308.86837      28070.349      28070.349     -1197.3817     -1197.3817    
     54000  -10432.863     -10432.863     -10514.685     -10514.685      316.66102      316.66102      28068.683      28068.683     -658.75758     -658.75758    
Loop time of 103.19 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.837 ns/day, 28.664 hours/ns, 9.691 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    | 102.67     | 102.67     | 102.67     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081792   | 0.081792   | 0.081792   |   0.0 |  0.08
Output  | 0.0001692  | 0.0001692  | 0.0001692  |   0.0 |  0.00
Modify  | 0.38501    | 0.38501    | 0.38501    |   0.0 |  0.37
Other   |            | 0.05804    |            |       |  0.06

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

Total # of neighbors = 118898
Ave neighs/atom = 59.449
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.613085922384, Press = 0.0429516793645972
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -10432.863     -10432.863     -10514.685     -10514.685      316.66102      316.66102      28068.683      28068.683     -658.75758     -658.75758    
     55000  -10436.832     -10436.832     -10515.59      -10515.59       304.79965      304.79965      28044.615      28044.615      540.28107      540.28107    
Loop time of 102.842 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.840 ns/day, 28.567 hours/ns, 9.724 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    | 102.32     | 102.32     | 102.32     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080945   | 0.080945   | 0.080945   |   0.0 |  0.08
Output  | 0.0002039  | 0.0002039  | 0.0002039  |   0.0 |  0.00
Modify  | 0.38581    | 0.38581    | 0.38581    |   0.0 |  0.38
Other   |            | 0.0577     |            |       |  0.06

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

Total # of neighbors = 118984
Ave neighs/atom = 59.492
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.6218328186, Press = -0.344603020541383
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -10436.832     -10436.832     -10515.59      -10515.59       304.79965      304.79965      28044.615      28044.615      540.28107      540.28107    
     56000  -10436.203     -10436.203     -10515.357     -10515.357      306.3338       306.3338       28003.355      28003.355      2726.738       2726.738     
Loop time of 103.824 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.840 hours/ns, 9.632 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.3      | 103.3      | 103.3      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081365   | 0.081365   | 0.081365   |   0.0 |  0.08
Output  | 0.00018831 | 0.00018831 | 0.00018831 |   0.0 |  0.00
Modify  | 0.38886    | 0.38886    | 0.38886    |   0.0 |  0.37
Other   |            | 0.0587     |            |       |  0.06

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

Total # of neighbors = 118986
Ave neighs/atom = 59.493
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.587217870961, Press = -0.150440922305408
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -10436.203     -10436.203     -10515.357     -10515.357      306.3338       306.3338       28003.355      28003.355      2726.738       2726.738     
     57000  -10435.087     -10435.087     -10516.423     -10516.423      314.77928      314.77928      28002.786      28002.786      2825.3254      2825.3254    
Loop time of 102.761 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.841 ns/day, 28.545 hours/ns, 9.731 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    | 102.24     | 102.24     | 102.24     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082228   | 0.082228   | 0.082228   |   0.0 |  0.08
Output  | 0.00016722 | 0.00016722 | 0.00016722 |   0.0 |  0.00
Modify  | 0.38313    | 0.38313    | 0.38313    |   0.0 |  0.37
Other   |            | 0.05769    |            |       |  0.06

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

Total # of neighbors = 119162
Ave neighs/atom = 59.581
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.610398074684, Press = 0.891359320342866
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -10435.087     -10435.087     -10516.423     -10516.423      314.77928      314.77928      28002.786      28002.786      2825.3254      2825.3254    
     58000  -10434.885     -10434.885     -10515.789     -10515.789      313.1079       313.1079       28041.266      28041.266      828.90348      828.90348    
Loop time of 102.276 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.845 ns/day, 28.410 hours/ns, 9.777 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.75     | 101.75     | 101.75     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080949   | 0.080949   | 0.080949   |   0.0 |  0.08
Output  | 0.00016524 | 0.00016524 | 0.00016524 |   0.0 |  0.00
Modify  | 0.38427    | 0.38427    | 0.38427    |   0.0 |  0.38
Other   |            | 0.0575     |            |       |  0.06

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

Total # of neighbors = 119138
Ave neighs/atom = 59.569
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.66514650645, Press = 1.09240434035657
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -10434.885     -10434.885     -10515.789     -10515.789      313.1079       313.1079       28041.266      28041.266      828.90348      828.90348    
     59000  -10432.677     -10432.677     -10514.736     -10514.736      317.5758       317.5758       28064.395      28064.395     -332.33892     -332.33892    
Loop time of 102.792 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.841 ns/day, 28.553 hours/ns, 9.728 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    | 102.27     | 102.27     | 102.27     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080723   | 0.080723   | 0.080723   |   0.0 |  0.08
Output  | 0.0002089  | 0.0002089  | 0.0002089  |   0.0 |  0.00
Modify  | 0.38398    | 0.38398    | 0.38398    |   0.0 |  0.37
Other   |            | 0.0575     |            |       |  0.06

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

Total # of neighbors = 119046
Ave neighs/atom = 59.523
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.726389634813, Press = 0.697434643329632
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -10432.677     -10432.677     -10514.736     -10514.736      317.5758       317.5758       28064.395      28064.395     -332.33892     -332.33892    
     60000  -10432.128     -10432.128     -10514.912     -10514.912      320.38481      320.38481      28067.976      28067.976     -487.75826     -487.75826    
Loop time of 101.666 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.850 ns/day, 28.241 hours/ns, 9.836 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.15     | 101.15     | 101.15     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08069    | 0.08069    | 0.08069    |   0.0 |  0.08
Output  | 0.00016419 | 0.00016419 | 0.00016419 |   0.0 |  0.00
Modify  | 0.37749    | 0.37749    | 0.37749    |   0.0 |  0.37
Other   |            | 0.05715    |            |       |  0.06

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

Total # of neighbors = 118874
Ave neighs/atom = 59.437
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.756234350788, Press = 0.3631676862324
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -10432.128     -10432.128     -10514.912     -10514.912      320.38481      320.38481      28067.976      28067.976     -487.75826     -487.75826    
     61000  -10434.465     -10434.465     -10514.354     -10514.354      309.18043      309.18043      28054.609      28054.609      35.94543       35.94543     
Loop time of 104.749 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.097 hours/ns, 9.547 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    | 104.21     | 104.21     | 104.21     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082067   | 0.082067   | 0.082067   |   0.0 |  0.08
Output  | 0.00020469 | 0.00020469 | 0.00020469 |   0.0 |  0.00
Modify  | 0.39599    | 0.39599    | 0.39599    |   0.0 |  0.38
Other   |            | 0.05888    |            |       |  0.06

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

Total # of neighbors = 118908
Ave neighs/atom = 59.454
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.81611860976, Press = 0.181114202965474
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -10434.465     -10434.465     -10514.354     -10514.354      309.18043      309.18043      28054.609      28054.609      35.94543       35.94543     
     62000  -10430.186     -10430.186     -10515.022     -10515.022      328.32363      328.32363      28054.418      28054.418      91.617725      91.617725    
Loop time of 103.402 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.723 hours/ns, 9.671 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    | 102.87     | 102.87     | 102.87     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081937   | 0.081937   | 0.081937   |   0.0 |  0.08
Output  | 0.00016415 | 0.00016415 | 0.00016415 |   0.0 |  0.00
Modify  | 0.38955    | 0.38955    | 0.38955    |   0.0 |  0.38
Other   |            | 0.058      |            |       |  0.06

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

Total # of neighbors = 118996
Ave neighs/atom = 59.498
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.833475334825, Press = 0.271937314612172
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -10430.186     -10430.186     -10515.022     -10515.022      328.32363      328.32363      28054.418      28054.418      91.617725      91.617725    
     63000  -10436.175     -10436.175     -10514.408     -10514.408      302.76953      302.76953      28049.59       28049.59       253.31353      253.31353    
Loop time of 102.387 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.844 ns/day, 28.441 hours/ns, 9.767 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.86     | 101.86     | 101.86     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082125   | 0.082125   | 0.082125   |   0.0 |  0.08
Output  | 0.0001664  | 0.0001664  | 0.0001664  |   0.0 |  0.00
Modify  | 0.38243    | 0.38243    | 0.38243    |   0.0 |  0.37
Other   |            | 0.05787    |            |       |  0.06

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

Total # of neighbors = 119032
Ave neighs/atom = 59.516
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.853933303019, Press = 0.345016542399418
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -10436.175     -10436.175     -10514.408     -10514.408      302.76953      302.76953      28049.59       28049.59       253.31353      253.31353    
     64000  -10430.85      -10430.85      -10512.695     -10512.695      316.74879      316.74879      28063.539      28063.539     -270.52868     -270.52868    
Loop time of 102.427 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.844 ns/day, 28.452 hours/ns, 9.763 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.91     | 101.91     | 101.91     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081895   | 0.081895   | 0.081895   |   0.0 |  0.08
Output  | 0.00016352 | 0.00016352 | 0.00016352 |   0.0 |  0.00
Modify  | 0.38051    | 0.38051    | 0.38051    |   0.0 |  0.37
Other   |            | 0.05798    |            |       |  0.06

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

Total # of neighbors = 119080
Ave neighs/atom = 59.54
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.874319910478, Press = 0.550408549939846
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -10430.85      -10430.85      -10512.695     -10512.695      316.74879      316.74879      28063.539      28063.539     -270.52868     -270.52868    
     65000  -10434.87      -10434.87      -10516.373     -10516.373      315.42567      315.42567      28071.985      28071.985     -999.67735     -999.67735    
Loop time of 101.766 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.849 ns/day, 28.268 hours/ns, 9.826 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.25     | 101.25     | 101.25     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081181   | 0.081181   | 0.081181   |   0.0 |  0.08
Output  | 0.00016528 | 0.00016528 | 0.00016528 |   0.0 |  0.00
Modify  | 0.37822    | 0.37822    | 0.37822    |   0.0 |  0.37
Other   |            | 0.05784    |            |       |  0.06

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

Total # of neighbors = 119080
Ave neighs/atom = 59.54
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.918604025698, Press = 0.568299906230635
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -10434.87      -10434.87      -10516.373     -10516.373      315.42567      315.42567      28071.985      28071.985     -999.67735     -999.67735    
     66000  -10433.63      -10433.63      -10514.445     -10514.445      312.76391      312.76391      28092.451      28092.451     -2006.9646     -2006.9646    
Loop time of 104.437 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.010 hours/ns, 9.575 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.91     | 103.91     | 103.91     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081781   | 0.081781   | 0.081781   |   0.0 |  0.08
Output  | 0.0001649  | 0.0001649  | 0.0001649  |   0.0 |  0.00
Modify  | 0.3906     | 0.3906     | 0.3906     |   0.0 |  0.37
Other   |            | 0.05843    |            |       |  0.06

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

Total # of neighbors = 118888
Ave neighs/atom = 59.444
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.939966701258, Press = 0.109602739801634
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -10433.63      -10433.63      -10514.445     -10514.445      312.76391      312.76391      28092.451      28092.451     -2006.9646     -2006.9646    
     67000  -10435.314     -10435.314     -10515.989     -10515.989      312.21843      312.21843      28089.298      28089.298     -1957.249      -1957.249     
Loop time of 104.189 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.941 hours/ns, 9.598 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.66     | 103.66     | 103.66     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081719   | 0.081719   | 0.081719   |   0.0 |  0.08
Output  | 0.00016595 | 0.00016595 | 0.00016595 |   0.0 |  0.00
Modify  | 0.39162    | 0.39162    | 0.39162    |   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:           3114 ave        3114 max        3114 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:       118874 ave      118874 max      118874 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118874
Ave neighs/atom = 59.437
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.943524835906, Press = -0.603158749331374
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -10435.314     -10435.314     -10515.989     -10515.989      312.21843      312.21843      28089.298      28089.298     -1957.249      -1957.249     
     68000  -10429.956     -10429.956     -10512.233     -10512.233      318.42301      318.42301      28066.086      28066.086     -195.75716     -195.75716    
Loop time of 103.445 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.835 ns/day, 28.735 hours/ns, 9.667 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    | 102.92     | 102.92     | 102.92     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081235   | 0.081235   | 0.081235   |   0.0 |  0.08
Output  | 0.00022954 | 0.00022954 | 0.00022954 |   0.0 |  0.00
Modify  | 0.38901    | 0.38901    | 0.38901    |   0.0 |  0.38
Other   |            | 0.05758    |            |       |  0.06

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

Total # of neighbors = 118864
Ave neighs/atom = 59.432
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.968658607642, Press = -1.1642642116283
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -10429.956     -10429.956     -10512.233     -10512.233      318.42301      318.42301      28066.086      28066.086     -195.75716     -195.75716    
     69000  -10434.398     -10434.398     -10516.489     -10516.489      317.70073      317.70073      28037.414      28037.414      827.27272      827.27272    
Loop time of 104.517 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.032 hours/ns, 9.568 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.99     | 103.99     | 103.99     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08183    | 0.08183    | 0.08183    |   0.0 |  0.08
Output  | 0.0001659  | 0.0001659  | 0.0001659  |   0.0 |  0.00
Modify  | 0.39046    | 0.39046    | 0.39046    |   0.0 |  0.37
Other   |            | 0.05802    |            |       |  0.06

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

Total # of neighbors = 119030
Ave neighs/atom = 59.515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 312.999895764428, Press = -0.234778887861426
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -10434.398     -10434.398     -10516.489     -10516.489      317.70073      317.70073      28037.414      28037.414      827.27272      827.27272    
     70000  -10429.798     -10429.798     -10512.199     -10512.199      318.8972       318.8972       28046.624      28046.624      889.33548      889.33548    
Loop time of 103.309 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.697 hours/ns, 9.680 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    | 102.78     | 102.78     | 102.78     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081676   | 0.081676   | 0.081676   |   0.0 |  0.08
Output  | 0.00016813 | 0.00016813 | 0.00016813 |   0.0 |  0.00
Modify  | 0.3856     | 0.3856     | 0.3856     |   0.0 |  0.37
Other   |            | 0.05795    |            |       |  0.06

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

Total # of neighbors = 119000
Ave neighs/atom = 59.5
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.048621195862, Press = 0.284894060998421
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -10429.798     -10429.798     -10512.199     -10512.199      318.8972       318.8972       28046.624      28046.624      889.33548      889.33548    
     71000  -10432.469     -10432.469     -10513.174     -10513.174      312.3351       312.3351       28056.416      28056.416      64.398528      64.398528    
Loop time of 103.438 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.835 ns/day, 28.733 hours/ns, 9.668 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    | 102.91     | 102.91     | 102.91     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081379   | 0.081379   | 0.081379   |   0.0 |  0.08
Output  | 0.00016523 | 0.00016523 | 0.00016523 |   0.0 |  0.00
Modify  | 0.38477    | 0.38477    | 0.38477    |   0.0 |  0.37
Other   |            | 0.05844    |            |       |  0.06

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

Total # of neighbors = 119088
Ave neighs/atom = 59.544
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.052103875261, Press = 0.487177453107371
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -10432.469     -10432.469     -10513.174     -10513.174      312.3351       312.3351       28056.416      28056.416      64.398528      64.398528    
     72000  -10434.503     -10434.503     -10516.813     -10516.813      318.54543      318.54543      28070.282      28070.282     -1014.8483     -1014.8483    
Loop time of 103.34 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.706 hours/ns, 9.677 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    | 102.81     | 102.81     | 102.81     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081934   | 0.081934   | 0.081934   |   0.0 |  0.08
Output  | 0.00016597 | 0.00016597 | 0.00016597 |   0.0 |  0.00
Modify  | 0.38813    | 0.38813    | 0.38813    |   0.0 |  0.38
Other   |            | 0.05759    |            |       |  0.06

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

Total # of neighbors = 118986
Ave neighs/atom = 59.493
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 313.048286273795, Press = 0.599423807431341
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
Neighbor list info ...
  update every 1 steps, delay 10 steps, check yes
  max neighbors/atom: 2000, page size: 100000
  master list distance cutoff = 6
  ghost atom cutoff = 6
  binsize = 3, bins = 11 11 11
  1 neighbor lists, perpetual/occasional/extra = 1 0 0
  (1) pair kim, perpetual
      attributes: full, newton off, cut 6
      pair build: full/bin/atomonly
      stencil: full/bin/3d
      bin: standard
Per MPI rank memory allocation (min/avg/max) = 3.702 | 3.702 | 3.702 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -10434.503     -10434.503     -10516.813     -10516.813      318.54543      318.54543      28070.282      28070.282     -1014.8483     -1014.8483    
     73000  -10431.893     -10431.893     -10512.528     -10512.528      312.06762      312.06762      28117.647      28117.647     -3119.5614     -3119.5614    
Loop time of 103.581 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.772 hours/ns, 9.654 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.05     | 103.05     | 103.05     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081258   | 0.081258   | 0.081258   |   0.0 |  0.08
Output  | 0.00016671 | 0.00016671 | 0.00016671 |   0.0 |  0.00
Modify  | 0.38656    | 0.38656    | 0.38656    |   0.0 |  0.37
Other   |            | 0.05827    |            |       |  0.06

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

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0