# 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.003 seconds

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

kim_interactions V

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

kim interactions V
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_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 273.15*${_u_temperature}
variable temp_converted equal 273.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 273.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 273.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 273.15 273.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  "273.15 - 0.2"
variable      T_up  equal  "273.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  -10529.42      -10529.42      -10600         -10600          273.15         273.15         27848.129      27848.129      2707.0852      2707.0852    
      1000  -10453.236     -10453.236     -10529.517     -10529.517      295.21491      295.21491      28071.523      28071.523     -2541.621      -2541.621     
Loop time of 95.4446 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.905 ns/day, 26.512 hours/ns, 10.477 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.958     | 94.958     | 94.958     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.076376   | 0.076376   | 0.076376   |   0.0 |  0.08
Output  | 0.00025073 | 0.00025073 | 0.00025073 |   0.0 |  0.00
Modify  | 0.35371    | 0.35371    | 0.35371    |   0.0 |  0.37
Other   |            | 0.0563     |            |       |  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  -10453.236     -10453.236     -10529.517     -10529.517      295.21491      295.21491      28071.523      28071.523     -2541.621      -2541.621     
      2000  -10456.004     -10456.004     -10529.373     -10529.373      283.94332      283.94332      28006.824      28006.824      1064.0876      1064.0876    
Loop time of 100.146 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.863 ns/day, 27.818 hours/ns, 9.985 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    | 99.658     | 99.658     | 99.658     |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078831   | 0.078831   | 0.078831   |   0.0 |  0.08
Output  | 0.00020132 | 0.00020132 | 0.00020132 |   0.0 |  0.00
Modify  | 0.35281    | 0.35281    | 0.35281    |   0.0 |  0.35
Other   |            | 0.05692    |            |       |  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:       118680 ave      118680 max      118680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118680
Ave neighs/atom = 59.34
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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  -10456.004     -10456.004     -10529.373     -10529.373      283.94332      283.94332      28006.824      28006.824      1064.0876      1064.0876    
      3000  -10455.81      -10455.81      -10526.236     -10526.236      272.55511      272.55511      28023.717      28023.717      408.04727      408.04727    
Loop time of 99.8281 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.865 ns/day, 27.730 hours/ns, 10.017 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    | 99.346     | 99.346     | 99.346     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07804    | 0.07804    | 0.07804    |   0.0 |  0.08
Output  | 0.00020276 | 0.00020276 | 0.00020276 |   0.0 |  0.00
Modify  | 0.34722    | 0.34722    | 0.34722    |   0.0 |  0.35
Other   |            | 0.05698    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3092 ave        3092 max        3092 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118868 ave      118868 max      118868 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118868
Ave neighs/atom = 59.434
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 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  -10455.81      -10455.81      -10526.236     -10526.236      272.55511      272.55511      28023.717      28023.717      408.04727      408.04727    
      4000  -10455.13      -10455.13      -10523.85      -10523.85       265.95509      265.95509      28036.69       28036.69      -490.79152     -490.79152    
Loop time of 99.9367 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.865 ns/day, 27.760 hours/ns, 10.006 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    | 99.452     | 99.452     | 99.452     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.078924   | 0.078924   | 0.078924   |   0.0 |  0.08
Output  | 0.00020349 | 0.00020349 | 0.00020349 |   0.0 |  0.00
Modify  | 0.3489     | 0.3489     | 0.3489     |   0.0 |  0.35
Other   |            | 0.05663    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3136 ave        3136 max        3136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118928 ave      118928 max      118928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118928
Ave neighs/atom = 59.464
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -10455.13      -10455.13      -10523.85      -10523.85       265.95509      265.95509      28036.69       28036.69      -490.79152     -490.79152    
      5000  -10455.435     -10455.435     -10523.765     -10523.765      264.44521      264.44521      28002.365      28002.365      1574.6831      1574.6831    
Loop time of 102.004 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.847 ns/day, 28.335 hours/ns, 9.804 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.5      | 101.5      | 101.5      |   0.0 | 99.51
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079548   | 0.079548   | 0.079548   |   0.0 |  0.08
Output  | 0.00016376 | 0.00016376 | 0.00016376 |   0.0 |  0.00
Modify  | 0.36268    | 0.36268    | 0.36268    |   0.0 |  0.36
Other   |            | 0.05727    |            |       |  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:       118904 ave      118904 max      118904 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118904
Ave neighs/atom = 59.452
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 275.58113520897, Press = -852.047562757231
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10455.435     -10455.435     -10523.765     -10523.765      264.44521      264.44521      28002.365      28002.365      1574.6831      1574.6831    
      6000  -10454.76      -10454.76      -10524.642     -10524.642      270.45007      270.45007      28067.782      28067.782     -2315.9486     -2315.9486    
Loop time of 102.219 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.845 ns/day, 28.394 hours/ns, 9.783 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.7      | 101.7      | 101.7      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080023   | 0.080023   | 0.080023   |   0.0 |  0.08
Output  | 0.00016832 | 0.00016832 | 0.00016832 |   0.0 |  0.00
Modify  | 0.38297    | 0.38297    | 0.38297    |   0.0 |  0.37
Other   |            | 0.0579     |            |       |  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:       119068 ave      119068 max      119068 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119068
Ave neighs/atom = 59.534
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.762573951577, Press = -13.0393585023157
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10454.76      -10454.76      -10524.642     -10524.642      270.45007      270.45007      28067.782      28067.782     -2315.9486     -2315.9486    
      7000  -10456.934     -10456.934     -10530.202     -10530.202      283.5554       283.5554       27978.962      27978.962      2463.0959      2463.0959    
Loop time of 103.145 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.838 ns/day, 28.651 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.07915    | 0.07915    | 0.07915    |   0.0 |  0.08
Output  | 0.00016393 | 0.00016393 | 0.00016393 |   0.0 |  0.00
Modify  | 0.38539    | 0.38539    | 0.38539    |   0.0 |  0.37
Other   |            | 0.05785    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3086 ave        3086 max        3086 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118772 ave      118772 max      118772 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118772
Ave neighs/atom = 59.386
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.42264593917, Press = -22.4672510921374
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
      7000  -10456.934     -10456.934     -10530.202     -10530.202      283.5554       283.5554       27978.962      27978.962      2463.0959      2463.0959    
      8000  -10453.876     -10453.876     -10527.449     -10527.449      284.73496      284.73496      28057.938      28057.938     -1582.4163     -1582.4163    
Loop time of 103.302 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.695 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.77     | 102.77     | 102.77     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080821   | 0.080821   | 0.080821   |   0.0 |  0.08
Output  | 0.00016458 | 0.00016458 | 0.00016458 |   0.0 |  0.00
Modify  | 0.38882    | 0.38882    | 0.38882    |   0.0 |  0.38
Other   |            | 0.05818    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3116 ave        3116 max        3116 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118826 ave      118826 max      118826 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118826
Ave neighs/atom = 59.413
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.566705898039, Press = -15.5754815191822
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10453.876     -10453.876     -10527.449     -10527.449      284.73496      284.73496      28057.938      28057.938     -1582.4163     -1582.4163    
      9000  -10456.038     -10456.038     -10526.918     -10526.918      274.31171      274.31171      28011.884      28011.884      671.37983      671.37983    
Loop time of 102.347 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.844 ns/day, 28.430 hours/ns, 9.771 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.82     | 101.82     | 101.82     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08019    | 0.08019    | 0.08019    |   0.0 |  0.08
Output  | 0.00016325 | 0.00016325 | 0.00016325 |   0.0 |  0.00
Modify  | 0.38366    | 0.38366    | 0.38366    |   0.0 |  0.37
Other   |            | 0.05826    |            |       |  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:       118746 ave      118746 max      118746 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118746
Ave neighs/atom = 59.373
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.728312121407, Press = -7.11244804267561
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10456.038     -10456.038     -10526.918     -10526.918      274.31171      274.31171      28011.884      28011.884      671.37983      671.37983    
     10000  -10456.752     -10456.752     -10525.553     -10525.553      266.26705      266.26705      28029.415      28029.415     -96.685626     -96.685626    
Loop time of 103.007 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.613 hours/ns, 9.708 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.48     | 102.48     | 102.48     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080719   | 0.080719   | 0.080719   |   0.0 |  0.08
Output  | 0.00016223 | 0.00016223 | 0.00016223 |   0.0 |  0.00
Modify  | 0.38861    | 0.38861    | 0.38861    |   0.0 |  0.38
Other   |            | 0.05792    |            |       |  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:       118894 ave      118894 max      118894 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118894
Ave neighs/atom = 59.447
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.845383212315, Press = -11.3550668625551
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10456.752     -10456.752     -10525.553     -10525.553      266.26705      266.26705      28029.415      28029.415     -96.685626     -96.685626    
     11000  -10455.464     -10455.464     -10523.919     -10523.919      264.92908      264.92908      28024.316      28024.316      338.84192      338.84192    
Loop time of 103.26 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.837 ns/day, 28.683 hours/ns, 9.684 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.73     | 102.73     | 102.73     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081491   | 0.081491   | 0.081491   |   0.0 |  0.08
Output  | 0.00026866 | 0.00026866 | 0.00026866 |   0.0 |  0.00
Modify  | 0.38757    | 0.38757    | 0.38757    |   0.0 |  0.38
Other   |            | 0.05833    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3162 ave        3162 max        3162 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118892 ave      118892 max      118892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118892
Ave neighs/atom = 59.446
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.471343575905, Press = -5.60768827917235
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10455.464     -10455.464     -10523.919     -10523.919      264.92908      264.92908      28024.316      28024.316      338.84192      338.84192    
     12000  -10459.493     -10459.493     -10526.896     -10526.896      260.8569       260.8569       28022.55       28022.55       202.24861      202.24861    
Loop time of 102.277 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.080338   | 0.080338   | 0.080338   |   0.0 |  0.08
Output  | 0.00019786 | 0.00019786 | 0.00019786 |   0.0 |  0.00
Modify  | 0.3838     | 0.3838     | 0.3838     |   0.0 |  0.38
Other   |            | 0.05799    |            |       |  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:       118798 ave      118798 max      118798 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118798
Ave neighs/atom = 59.399
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.25791888539, Press = -8.3038281977266
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10459.493     -10459.493     -10526.896     -10526.896      260.8569       260.8569       28022.55       28022.55       202.24861      202.24861    
     13000  -10453.853     -10453.853     -10524.105     -10524.105      271.88068      271.88068      28038.183      28038.183     -464.2255      -464.2255     
Loop time of 102.527 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.843 ns/day, 28.480 hours/ns, 9.753 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        | 102        | 102        |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080464   | 0.080464   | 0.080464   |   0.0 |  0.08
Output  | 0.00020622 | 0.00020622 | 0.00020622 |   0.0 |  0.00
Modify  | 0.38543    | 0.38543    | 0.38543    |   0.0 |  0.38
Other   |            | 0.05802    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3116 ave        3116 max        3116 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118846 ave      118846 max      118846 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118846
Ave neighs/atom = 59.423
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.001128365025, Press = -4.84730135547541
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10453.853     -10453.853     -10524.105     -10524.105      271.88068      271.88068      28038.183      28038.183     -464.2255      -464.2255     
     14000  -10454.043     -10454.043     -10525.731     -10525.731      277.43946      277.43946      28013.47       28013.47       835.72549      835.72549    
Loop time of 103.988 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.886 hours/ns, 9.616 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.080887   | 0.080887   | 0.080887   |   0.0 |  0.08
Output  | 0.00048831 | 0.00048831 | 0.00048831 |   0.0 |  0.00
Modify  | 0.39097    | 0.39097    | 0.39097    |   0.0 |  0.38
Other   |            | 0.05899    |            |       |  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:       118842 ave      118842 max      118842 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118842
Ave neighs/atom = 59.421
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.775918151358, Press = -6.37926116644446
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10454.043     -10454.043     -10525.731     -10525.731      277.43946      277.43946      28013.47       28013.47       835.72549      835.72549    
     15000  -10457.832     -10457.832     -10526.869     -10526.869      267.18225      267.18225      28063.708      28063.708     -2131.2044     -2131.2044    
Loop time of 105.642 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.818 ns/day, 29.345 hours/ns, 9.466 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.1      | 105.1      | 105.1      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081673   | 0.081673   | 0.081673   |   0.0 |  0.08
Output  | 0.00020277 | 0.00020277 | 0.00020277 |   0.0 |  0.00
Modify  | 0.39847    | 0.39847    | 0.39847    |   0.0 |  0.38
Other   |            | 0.05868    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3105 ave        3105 max        3105 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118892 ave      118892 max      118892 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118892
Ave neighs/atom = 59.446
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.705163979895, Press = -6.39022183279364
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10457.832     -10457.832     -10526.869     -10526.869      267.18225      267.18225      28063.708      28063.708     -2131.2044     -2131.2044    
     16000  -10455.707     -10455.707     -10522.946     -10522.946      260.22067      260.22067      27977.3        27977.3        2846.2961      2846.2961    
Loop time of 104.629 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.063 hours/ns, 9.558 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.09     | 104.09     | 104.09     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081219   | 0.081219   | 0.081219   |   0.0 |  0.08
Output  | 0.00016594 | 0.00016594 | 0.00016594 |   0.0 |  0.00
Modify  | 0.39741    | 0.39741    | 0.39741    |   0.0 |  0.38
Other   |            | 0.05889    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3096 ave        3096 max        3096 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118788 ave      118788 max      118788 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118788
Ave neighs/atom = 59.394
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.725233313796, Press = -1.22332070186222
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10455.707     -10455.707     -10522.946     -10522.946      260.22067      260.22067      27977.3        27977.3        2846.2961      2846.2961    
     17000  -10455.417     -10455.417     -10526.799     -10526.799      276.25689      276.25689      28057.594      28057.594     -1651.1669     -1651.1669    
Loop time of 104.108 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.919 hours/ns, 9.605 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.57     | 103.57     | 103.57     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082222   | 0.082222   | 0.082222   |   0.0 |  0.08
Output  | 0.00016491 | 0.00016491 | 0.00016491 |   0.0 |  0.00
Modify  | 0.39269    | 0.39269    | 0.39269    |   0.0 |  0.38
Other   |            | 0.05864    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3175 ave        3175 max        3175 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118994 ave      118994 max      118994 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118994
Ave neighs/atom = 59.497
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.822881045403, Press = -7.30578734408761
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10455.417     -10455.417     -10526.799     -10526.799      276.25689      276.25689      28057.594      28057.594     -1651.1669     -1651.1669    
     18000  -10456.312     -10456.312     -10525.815     -10525.815      268.98297      268.98297      28020.473      28020.473      341.73584      341.73584    
Loop time of 105.3 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.821 ns/day, 29.250 hours/ns, 9.497 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.76     | 104.76     | 104.76     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082311   | 0.082311   | 0.082311   |   0.0 |  0.08
Output  | 0.00022625 | 0.00022625 | 0.00022625 |   0.0 |  0.00
Modify  | 0.39934    | 0.39934    | 0.39934    |   0.0 |  0.38
Other   |            | 0.05898    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3098 ave        3098 max        3098 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118770 ave      118770 max      118770 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118770
Ave neighs/atom = 59.385
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.919664892917, Press = -1.68500369896557
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10456.312     -10456.312     -10525.815     -10525.815      268.98297      268.98297      28020.473      28020.473      341.73584      341.73584    
     19000  -10452.697     -10452.697     -10523.415     -10523.415      273.68523      273.68523      28031.522      28031.522      141.56943      141.56943    
Loop time of 104.857 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.127 hours/ns, 9.537 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.32     | 104.32     | 104.32     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080926   | 0.080926   | 0.080926   |   0.0 |  0.08
Output  | 0.00019955 | 0.00019955 | 0.00019955 |   0.0 |  0.00
Modify  | 0.39884    | 0.39884    | 0.39884    |   0.0 |  0.38
Other   |            | 0.05854    |            |       |  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:       118856 ave      118856 max      118856 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118856
Ave neighs/atom = 59.428
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.086784629675, Press = -4.50968803996446
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10452.697     -10452.697     -10523.415     -10523.415      273.68523      273.68523      28031.522      28031.522      141.56943      141.56943    
     20000  -10454.246     -10454.246     -10526.033     -10526.033      277.82241      277.82241      28031.268      28031.268     -122.61299     -122.61299    
Loop time of 103.372 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.714 hours/ns, 9.674 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.84     | 102.84     | 102.84     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081408   | 0.081408   | 0.081408   |   0.0 |  0.08
Output  | 0.00022438 | 0.00022438 | 0.00022438 |   0.0 |  0.00
Modify  | 0.38819    | 0.38819    | 0.38819    |   0.0 |  0.38
Other   |            | 0.0582     |            |       |  0.06

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

Total # of neighbors = 118938
Ave neighs/atom = 59.469
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.05799156467, Press = -4.18016328906147
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10454.246     -10454.246     -10526.033     -10526.033      277.82241      277.82241      28031.268      28031.268     -122.61299     -122.61299    
     21000  -10460.483     -10460.483     -10528.157     -10528.157      261.9061       261.9061       28018.561      28018.561      2.9588688      2.9588688    
Loop time of 103.791 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.831 hours/ns, 9.635 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.26     | 103.26     | 103.26     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08042    | 0.08042    | 0.08042    |   0.0 |  0.08
Output  | 0.00016252 | 0.00016252 | 0.00016252 |   0.0 |  0.00
Modify  | 0.39287    | 0.39287    | 0.39287    |   0.0 |  0.38
Other   |            | 0.05801    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3099 ave        3099 max        3099 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118824 ave      118824 max      118824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118824
Ave neighs/atom = 59.412
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.961316929578, Press = -2.84215231892223
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10460.483     -10460.483     -10528.157     -10528.157      261.9061       261.9061       28018.561      28018.561      2.9588688      2.9588688    
     22000  -10455.226     -10455.226     -10525.331     -10525.331      271.31294      271.31294      28028.288      28028.288     -127.28081     -127.28081    
Loop time of 102.72 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.841 ns/day, 28.533 hours/ns, 9.735 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.19     | 102.19     | 102.19     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080263   | 0.080263   | 0.080263   |   0.0 |  0.08
Output  | 0.00025953 | 0.00025953 | 0.00025953 |   0.0 |  0.00
Modify  | 0.38647    | 0.38647    | 0.38647    |   0.0 |  0.38
Other   |            | 0.05887    |            |       |  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:       118906 ave      118906 max      118906 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118906
Ave neighs/atom = 59.453
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.854656080248, Press = -3.46008761207728
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10455.226     -10455.226     -10525.331     -10525.331      271.31294      271.31294      28028.288      28028.288     -127.28081     -127.28081    
     23000  -10453.576     -10453.576     -10525.502     -10525.502      278.36244      278.36244      28037.096      28037.096     -487.04971     -487.04971    
Loop time of 105.344 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.820 ns/day, 29.262 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.81     | 104.81     | 104.81     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08236    | 0.08236    | 0.08236    |   0.0 |  0.08
Output  | 0.0001642  | 0.0001642  | 0.0001642  |   0.0 |  0.00
Modify  | 0.3953     | 0.3953     | 0.3953     |   0.0 |  0.38
Other   |            | 0.05831    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3130 ave        3130 max        3130 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118838 ave      118838 max      118838 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118838
Ave neighs/atom = 59.419
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.894877042007, Press = -2.40604969373869
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10453.576     -10453.576     -10525.502     -10525.502      278.36244      278.36244      28037.096      28037.096     -487.04971     -487.04971    
     24000  -10455.792     -10455.792     -10525.648     -10525.648      270.3491       270.3491       28013.431      28013.431      767.90297      767.90297    
Loop time of 103.351 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.709 hours/ns, 9.676 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.82     | 102.82     | 102.82     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080355   | 0.080355   | 0.080355   |   0.0 |  0.08
Output  | 0.00025816 | 0.00025816 | 0.00025816 |   0.0 |  0.00
Modify  | 0.3875     | 0.3875     | 0.3875     |   0.0 |  0.37
Other   |            | 0.05837    |            |       |  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:       118824 ave      118824 max      118824 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118824
Ave neighs/atom = 59.412
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.949589070168, Press = -3.91443652388015
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10455.792     -10455.792     -10525.648     -10525.648      270.3491       270.3491       28013.431      28013.431      767.90297      767.90297    
     25000  -10454.686     -10454.686     -10524.686     -10524.686      270.90686      270.90686      28055.844      28055.844     -1416.5508     -1416.5508    
Loop time of 104.107 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.830 ns/day, 28.918 hours/ns, 9.606 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.58     | 103.58     | 103.58     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080351   | 0.080351   | 0.080351   |   0.0 |  0.08
Output  | 0.0001646  | 0.0001646  | 0.0001646  |   0.0 |  0.00
Modify  | 0.38872    | 0.38872    | 0.38872    |   0.0 |  0.37
Other   |            | 0.05813    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3093 ave        3093 max        3093 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118938 ave      118938 max      118938 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118938
Ave neighs/atom = 59.469
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.970452251608, Press = -2.34193718101758
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10454.686     -10454.686     -10524.686     -10524.686      270.90686      270.90686      28055.844      28055.844     -1416.5508     -1416.5508    
     26000  -10453.71      -10453.71      -10523.769     -10523.769      271.13682      271.13682      27983.268      27983.268      2629.1287      2629.1287    
Loop time of 104.834 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.120 hours/ns, 9.539 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.3      | 104.3      | 104.3      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080858   | 0.080858   | 0.080858   |   0.0 |  0.08
Output  | 0.00020075 | 0.00020075 | 0.00020075 |   0.0 |  0.00
Modify  | 0.3933     | 0.3933     | 0.3933     |   0.0 |  0.38
Other   |            | 0.05872    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3102 ave        3102 max        3102 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118776 ave      118776 max      118776 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118776
Ave neighs/atom = 59.388
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.851279168847, Press = -2.57656912607864
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10453.71      -10453.71      -10523.769     -10523.769      271.13682      271.13682      27983.268      27983.268      2629.1287      2629.1287    
     27000  -10456.161     -10456.161     -10526.838     -10526.838      273.52635      273.52635      28074.259      28074.259     -2601.6508     -2601.6508    
Loop time of 103.699 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.833 ns/day, 28.805 hours/ns, 9.643 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.17     | 103.17     | 103.17     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080731   | 0.080731   | 0.080731   |   0.0 |  0.08
Output  | 0.00016463 | 0.00016463 | 0.00016463 |   0.0 |  0.00
Modify  | 0.39374    | 0.39374    | 0.39374    |   0.0 |  0.38
Other   |            | 0.05829    |            |       |  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:       119034 ave      119034 max      119034 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119034
Ave neighs/atom = 59.517
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.830533877978, Press = -3.51452236956256
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10456.161     -10456.161     -10526.838     -10526.838      273.52635      273.52635      28074.259      28074.259     -2601.6508     -2601.6508    
     28000  -10452.34      -10452.34      -10525.739     -10525.739      284.059        284.059        28012.334      28012.334      882.33565      882.33565    
Loop time of 105.735 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.817 ns/day, 29.371 hours/ns, 9.458 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.19     | 105.19     | 105.19     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081432   | 0.081432   | 0.081432   |   0.0 |  0.08
Output  | 0.00016356 | 0.00016356 | 0.00016356 |   0.0 |  0.00
Modify  | 0.39935    | 0.39935    | 0.39935    |   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:           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:       118674 ave      118674 max      118674 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118674
Ave neighs/atom = 59.337
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.948142400307, Press = -1.55390528430502
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10452.34      -10452.34      -10525.739     -10525.739      284.059        284.059        28012.334      28012.334      882.33565      882.33565    
     29000  -10456.215     -10456.215     -10527.457     -10527.457      275.71728      275.71728      28030.618      28030.618     -342.92684     -342.92684    
Loop time of 104.197 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.829 ns/day, 28.944 hours/ns, 9.597 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.48
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08255    | 0.08255    | 0.08255    |   0.0 |  0.08
Output  | 0.00017003 | 0.00017003 | 0.00017003 |   0.0 |  0.00
Modify  | 0.39547    | 0.39547    | 0.39547    |   0.0 |  0.38
Other   |            | 0.05843    |            |       |  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:       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 = 272.969114539244, Press = -2.86687614842241
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10456.215     -10456.215     -10527.457     -10527.457      275.71728      275.71728      28030.618      28030.618     -342.92684     -342.92684    
     30000  -10451.198     -10451.198     -10521.655     -10521.655      272.67659      272.67659      28031.49       28031.49       195.4922       195.4922     
Loop time of 106.06 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.461 hours/ns, 9.429 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.52     | 105.52     | 105.52     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081718   | 0.081718   | 0.081718   |   0.0 |  0.08
Output  | 0.00019883 | 0.00019883 | 0.00019883 |   0.0 |  0.00
Modify  | 0.39993    | 0.39993    | 0.39993    |   0.0 |  0.38
Other   |            | 0.05896    |            |       |  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:       118808 ave      118808 max      118808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118808
Ave neighs/atom = 59.404
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.025018120757, Press = -1.60613405952315
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10451.198     -10451.198     -10521.655     -10521.655      272.67659      272.67659      28031.49       28031.49       195.4922       195.4922     
     31000  -10458.211     -10458.211     -10527.302     -10527.302      267.39086      267.39086      28008.216      28008.216      824.26657      824.26657    
Loop time of 104.883 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.134 hours/ns, 9.534 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 104.34     | 104.34     | 104.34     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081921   | 0.081921   | 0.081921   |   0.0 |  0.08
Output  | 0.00016404 | 0.00016404 | 0.00016404 |   0.0 |  0.00
Modify  | 0.39778    | 0.39778    | 0.39778    |   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:           3145 ave        3145 max        3145 min
Histogram: 1 0 0 0 0 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 = 273.086130175682, Press = -3.18136218469258
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10458.211     -10458.211     -10527.302     -10527.302      267.39086      267.39086      28008.216      28008.216      824.26657      824.26657    
     32000  -10455.09      -10455.09      -10526.989     -10526.989      278.25948      278.25948      28061.607      28061.607     -2065.3495     -2065.3495    
Loop time of 102.412 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.844 ns/day, 28.448 hours/ns, 9.764 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.89     | 101.89     | 101.89     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079198   | 0.079198   | 0.079198   |   0.0 |  0.08
Output  | 0.00016299 | 0.00016299 | 0.00016299 |   0.0 |  0.00
Modify  | 0.38258    | 0.38258    | 0.38258    |   0.0 |  0.37
Other   |            | 0.05814    |            |       |  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:       118884 ave      118884 max      118884 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118884
Ave neighs/atom = 59.442
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.048483313751, Press = -1.18282207534293
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10455.09      -10455.09      -10526.989     -10526.989      278.25948      278.25948      28061.607      28061.607     -2065.3495     -2065.3495    
     33000  -10457.694     -10457.694     -10527.468     -10527.468      270.03504      270.03504      27979.397      27979.397      2405.1484      2405.1484    
Loop time of 104.507 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.827 ns/day, 29.030 hours/ns, 9.569 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.97     | 103.97     | 103.97     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08108    | 0.08108    | 0.08108    |   0.0 |  0.08
Output  | 0.00016372 | 0.00016372 | 0.00016372 |   0.0 |  0.00
Modify  | 0.39321    | 0.39321    | 0.39321    |   0.0 |  0.38
Other   |            | 0.05867    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3099 ave        3099 max        3099 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118686 ave      118686 max      118686 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118686
Ave neighs/atom = 59.343
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.966999455214, Press = -2.45140787478301
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10457.694     -10457.694     -10527.468     -10527.468      270.03504      270.03504      27979.397      27979.397      2405.1484      2405.1484    
     34000  -10457.032     -10457.032     -10526.135     -10526.135      267.43594      267.43594      28063.683      28063.683     -2087.4684     -2087.4684    
Loop time of 104.692 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.825 ns/day, 29.081 hours/ns, 9.552 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.16     | 104.16     | 104.16     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081372   | 0.081372   | 0.081372   |   0.0 |  0.08
Output  | 0.00016417 | 0.00016417 | 0.00016417 |   0.0 |  0.00
Modify  | 0.39542    | 0.39542    | 0.39542    |   0.0 |  0.38
Other   |            | 0.05892    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3136 ave        3136 max        3136 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118900 ave      118900 max      118900 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118900
Ave neighs/atom = 59.45
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.996929959174, Press = -2.16989659373152
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10457.032     -10457.032     -10526.135     -10526.135      267.43594      267.43594      28063.683      28063.683     -2087.4684     -2087.4684    
     35000  -10456.226     -10456.226     -10526.302     -10526.302      271.20483      271.20483      27999.502      27999.502      1395.8699      1395.8699    
Loop time of 106.449 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.812 ns/day, 29.569 hours/ns, 9.394 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.9      | 105.9      | 105.9      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.08223    | 0.08223    | 0.08223    |   0.0 |  0.08
Output  | 0.00016414 | 0.00016414 | 0.00016414 |   0.0 |  0.00
Modify  | 0.40457    | 0.40457    | 0.40457    |   0.0 |  0.38
Other   |            | 0.05957    |            |       |  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:       118742 ave      118742 max      118742 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118742
Ave neighs/atom = 59.371
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.046962963251, Press = -1.40536440103128
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10456.226     -10456.226     -10526.302     -10526.302      271.20483      271.20483      27999.502      27999.502      1395.8699      1395.8699    
     36000  -10455.328     -10455.328     -10524.618     -10524.618      268.1586       268.1586       28033.104      28033.104     -306.37366     -306.37366    
Loop time of 104.953 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.154 hours/ns, 9.528 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.42     | 104.42     | 104.42     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081287   | 0.081287   | 0.081287   |   0.0 |  0.08
Output  | 0.00016872 | 0.00016872 | 0.00016872 |   0.0 |  0.00
Modify  | 0.39476    | 0.39476    | 0.39476    |   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:           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:       118926 ave      118926 max      118926 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118926
Ave neighs/atom = 59.463
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.067201994502, Press = -2.18072106528386
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10455.328     -10455.328     -10524.618     -10524.618      268.1586       268.1586       28033.104      28033.104     -306.37366     -306.37366    
     37000  -10456.113     -10456.113     -10527.073     -10527.073      274.6225       274.6225       28023.08       28023.08       47.022622      47.022622    
Loop time of 103.398 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.722 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.079943   | 0.079943   | 0.079943   |   0.0 |  0.08
Output  | 0.00020141 | 0.00020141 | 0.00020141 |   0.0 |  0.00
Modify  | 0.38673    | 0.38673    | 0.38673    |   0.0 |  0.37
Other   |            | 0.05771    |            |       |  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:       118882 ave      118882 max      118882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118882
Ave neighs/atom = 59.441
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.094204947788, Press = -1.92835061786539
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10456.113     -10456.113     -10527.073     -10527.073      274.6225       274.6225       28023.08       28023.08       47.022622      47.022622    
     38000  -10455.138     -10455.138     -10525.56      -10525.56       272.53921      272.53921      28027.791      28027.791      36.137128      36.137128    
Loop time of 104.607 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.057 hours/ns, 9.560 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    | 104.07     | 104.07     | 104.07     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081127   | 0.081127   | 0.081127   |   0.0 |  0.08
Output  | 0.00019356 | 0.00019356 | 0.00019356 |   0.0 |  0.00
Modify  | 0.39125    | 0.39125    | 0.39125    |   0.0 |  0.37
Other   |            | 0.05913    |            |       |  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:       118822 ave      118822 max      118822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118822
Ave neighs/atom = 59.411
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.061238766962, Press = -2.3575445199827
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10455.138     -10455.138     -10525.56      -10525.56       272.53921      272.53921      28027.791      28027.791      36.137128      36.137128    
     39000  -10456.054     -10456.054     -10526.134     -10526.134      271.21531      271.21531      28031.297      28031.297     -230.24894     -230.24894    
Loop time of 105.145 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.207 hours/ns, 9.511 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.61     | 104.61     | 104.61     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082089   | 0.082089   | 0.082089   |   0.0 |  0.08
Output  | 0.00016513 | 0.00016513 | 0.00016513 |   0.0 |  0.00
Modify  | 0.39711    | 0.39711    | 0.39711    |   0.0 |  0.38
Other   |            | 0.05907    |            |       |  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:       118764 ave      118764 max      118764 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118764
Ave neighs/atom = 59.382
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.083820889015, Press = -1.12819903210012
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10456.054     -10456.054     -10526.134     -10526.134      271.21531      271.21531      28031.297      28031.297     -230.24894     -230.24894    
     40000  -10453.509     -10453.509     -10525.1       -10525.1        277.06535      277.06535      28010.066      28010.066      1056.1972      1056.1972    
Loop time of 103.786 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.832 ns/day, 28.829 hours/ns, 9.635 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.26     | 103.26     | 103.26     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081013   | 0.081013   | 0.081013   |   0.0 |  0.08
Output  | 0.00019582 | 0.00019582 | 0.00019582 |   0.0 |  0.00
Modify  | 0.38936    | 0.38936    | 0.38936    |   0.0 |  0.38
Other   |            | 0.05841    |            |       |  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:       118792 ave      118792 max      118792 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118792
Ave neighs/atom = 59.396
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.070213761646, Press = -2.43656231822999
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10453.509     -10453.509     -10525.1       -10525.1        277.06535      277.06535      28010.066      28010.066      1056.1972      1056.1972    
     41000  -10455.957     -10455.957     -10525.364     -10525.364      268.61076      268.61076      28054.023      28054.023     -1558.8791     -1558.8791    
Loop time of 103.595 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.776 hours/ns, 9.653 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.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081556   | 0.081556   | 0.081556   |   0.0 |  0.08
Output  | 0.0001665  | 0.0001665  | 0.0001665  |   0.0 |  0.00
Modify  | 0.38813    | 0.38813    | 0.38813    |   0.0 |  0.37
Other   |            | 0.05814    |            |       |  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:       118916 ave      118916 max      118916 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118916
Ave neighs/atom = 59.458
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.011353397274, Press = -1.28758904570023
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10455.957     -10455.957     -10525.364     -10525.364      268.61076      268.61076      28054.023      28054.023     -1558.8791     -1558.8791    
     42000  -10455.869     -10455.869     -10525.977     -10525.977      271.32725      271.32725      27991.165      27991.165      1887.7359      1887.7359    
Loop time of 102.712 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.841 ns/day, 28.531 hours/ns, 9.736 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 102.19     | 102.19     | 102.19     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081227   | 0.081227   | 0.081227   |   0.0 |  0.08
Output  | 0.00016417 | 0.00016417 | 0.00016417 |   0.0 |  0.00
Modify  | 0.38427    | 0.38427    | 0.38427    |   0.0 |  0.37
Other   |            | 0.0583     |            |       |  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:       118782 ave      118782 max      118782 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118782
Ave neighs/atom = 59.391
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.983083349708, Press = -2.01871761108089
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10455.869     -10455.869     -10525.977     -10525.977      271.32725      271.32725      27991.165      27991.165      1887.7359      1887.7359    
     43000  -10454.245     -10454.245     -10525.334     -10525.334      275.12421      275.12421      28090.743      28090.743     -3493.9054     -3493.9054    
Loop time of 103.944 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 103.41     | 103.41     | 103.41     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081256   | 0.081256   | 0.081256   |   0.0 |  0.08
Output  | 0.0001672  | 0.0001672  | 0.0001672  |   0.0 |  0.00
Modify  | 0.3885     | 0.3885     | 0.3885     |   0.0 |  0.37
Other   |            | 0.05891    |            |       |  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:       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 = 272.941538844903, Press = -2.1586804464334
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10454.245     -10454.245     -10525.334     -10525.334      275.12421      275.12421      28090.743      28090.743     -3493.9054     -3493.9054    
     44000  -10456.047     -10456.047     -10523.931     -10523.931      262.71673      262.71673      27969.538      27969.538      3287.4557      3287.4557    
Loop time of 104.942 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.823 ns/day, 29.151 hours/ns, 9.529 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.41     | 104.41     | 104.41     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081552   | 0.081552   | 0.081552   |   0.0 |  0.08
Output  | 0.00016668 | 0.00016668 | 0.00016668 |   0.0 |  0.00
Modify  | 0.39532    | 0.39532    | 0.39532    |   0.0 |  0.38
Other   |            | 0.05879    |            |       |  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:       118698 ave      118698 max      118698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118698
Ave neighs/atom = 59.349
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.943687405651, Press = -0.535153719288239
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10456.047     -10456.047     -10523.931     -10523.931      262.71673      262.71673      27969.538      27969.538      3287.4557      3287.4557    
     45000  -10455.641     -10455.641     -10526.645     -10526.645      274.79069      274.79069      28037.466      28037.466     -535.51836     -535.51836    
Loop time of 104.874 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.824 ns/day, 29.132 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.08096    | 0.08096    | 0.08096    |   0.0 |  0.08
Output  | 0.00016535 | 0.00016535 | 0.00016535 |   0.0 |  0.00
Modify  | 0.39549    | 0.39549    | 0.39549    |   0.0 |  0.38
Other   |            | 0.05861    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3109 ave        3109 max        3109 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       119008 ave      119008 max      119008 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119008
Ave neighs/atom = 59.504
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.877391680027, Press = -2.1246809665012
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10455.641     -10455.641     -10526.645     -10526.645      274.79069      274.79069      28037.466      28037.466     -535.51836     -535.51836    
     46000  -10456.772     -10456.772     -10527.819     -10527.819      274.9606       274.9606       28022.702      28022.702      151.93546      151.93546    
Loop time of 102.899 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.840 ns/day, 28.583 hours/ns, 9.718 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.37     | 102.37     | 102.37     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080608   | 0.080608   | 0.080608   |   0.0 |  0.08
Output  | 0.00016349 | 0.00016349 | 0.00016349 |   0.0 |  0.00
Modify  | 0.38602    | 0.38602    | 0.38602    |   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:           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:       118882 ave      118882 max      118882 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118882
Ave neighs/atom = 59.441
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.871460139685, Press = -0.983284737200423
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10456.772     -10456.772     -10527.819     -10527.819      274.9606       274.9606       28022.702      28022.702      151.93546      151.93546    
     47000  -10454.17      -10454.17      -10525.436     -10525.436      275.80491      275.80491      28017.837      28017.837      606.26635      606.26635    
Loop time of 104.55 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.826 ns/day, 29.042 hours/ns, 9.565 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.081759   | 0.081759   | 0.081759   |   0.0 |  0.08
Output  | 0.00016543 | 0.00016543 | 0.00016543 |   0.0 |  0.00
Modify  | 0.39654    | 0.39654    | 0.39654    |   0.0 |  0.38
Other   |            | 0.05893    |            |       |  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:       118814 ave      118814 max      118814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118814
Ave neighs/atom = 59.407
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.85744743756, Press = -2.09586686281829
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10454.17      -10454.17      -10525.436     -10525.436      275.80491      275.80491      28017.837      28017.837      606.26635      606.26635    
     48000  -10455.867     -10455.867     -10526.264     -10526.264      272.44642      272.44642      28062.38       28062.38      -1962.1947     -1962.1947    
Loop time of 105.159 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.822 ns/day, 29.211 hours/ns, 9.509 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.62     | 104.62     | 104.62     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081919   | 0.081919   | 0.081919   |   0.0 |  0.08
Output  | 0.00021533 | 0.00021533 | 0.00021533 |   0.0 |  0.00
Modify  | 0.39313    | 0.39313    | 0.39313    |   0.0 |  0.37
Other   |            | 0.05911    |            |       |  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:       118832 ave      118832 max      118832 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118832
Ave neighs/atom = 59.416
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.871520021604, Press = -0.78352874508812
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10455.867     -10455.867     -10526.264     -10526.264      272.44642      272.44642      28062.38       28062.38      -1962.1947     -1962.1947    
     49000  -10451.272     -10451.272     -10522.884     -10522.884      277.14739      277.14739      27978.935      27978.935      2988.5336      2988.5336    
Loop time of 103.973 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.831 ns/day, 28.882 hours/ns, 9.618 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.44     | 103.44     | 103.44     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081233   | 0.081233   | 0.081233   |   0.0 |  0.08
Output  | 0.00016634 | 0.00016634 | 0.00016634 |   0.0 |  0.00
Modify  | 0.3924     | 0.3924     | 0.3924     |   0.0 |  0.38
Other   |            | 0.05847    |            |       |  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:       118748 ave      118748 max      118748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118748
Ave neighs/atom = 59.374
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.919759655231, Press = -1.3728723895193
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10451.272     -10451.272     -10522.884     -10522.884      277.14739      277.14739      27978.935      27978.935      2988.5336      2988.5336    
     50000  -10457.093     -10457.093     -10526.188     -10526.188      267.40488      267.40488      28070.601      28070.601     -2373.9542     -2373.9542    
Loop time of 103.016 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.616 hours/ns, 9.707 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.49     | 102.49     | 102.49     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080883   | 0.080883   | 0.080883   |   0.0 |  0.08
Output  | 0.0001654  | 0.0001654  | 0.0001654  |   0.0 |  0.00
Modify  | 0.38622    | 0.38622    | 0.38622    |   0.0 |  0.37
Other   |            | 0.05788    |            |       |  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:       119084 ave      119084 max      119084 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 119084
Ave neighs/atom = 59.542
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.969848832618, Press = -1.87314509847822
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10457.093     -10457.093     -10526.188     -10526.188      267.40488      267.40488      28070.601      28070.601     -2373.9542     -2373.9542    
     51000  -10455.276     -10455.276     -10526.082     -10526.082      274.02649      274.02649      28007.289      28007.289      1135.3843      1135.3843    
Loop time of 106.022 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.815 ns/day, 29.451 hours/ns, 9.432 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.48     | 105.48     | 105.48     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.082436   | 0.082436   | 0.082436   |   0.0 |  0.08
Output  | 0.0001641  | 0.0001641  | 0.0001641  |   0.0 |  0.00
Modify  | 0.40302    | 0.40302    | 0.40302    |   0.0 |  0.38
Other   |            | 0.05947    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3120 ave        3120 max        3120 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118818 ave      118818 max      118818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118818
Ave neighs/atom = 59.409
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.972487669837, Press = -0.700500965776288
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10455.276     -10455.276     -10526.082     -10526.082      274.02649      274.02649      28007.289      28007.289      1135.3843      1135.3843    
     52000  -10458.007     -10458.007     -10526.861     -10526.861      266.47114      266.47114      28030.99       28030.99      -299.55708     -299.55708    
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.081071   | 0.081071   | 0.081071   |   0.0 |  0.08
Output  | 0.0004394  | 0.0004394  | 0.0004394  |   0.0 |  0.00
Modify  | 0.38619    | 0.38619    | 0.38619    |   0.0 |  0.38
Other   |            | 0.05789    |            |       |  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:       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 = 272.936236217029, Press = -2.07102580384188
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10458.007     -10458.007     -10526.861     -10526.861      266.47114      266.47114      28030.99       28030.99      -299.55708     -299.55708    
     53000  -10454.712     -10454.712     -10525.387     -10525.387      273.51949      273.51949      28033.817      28033.817     -183.2062      -183.2062     
Loop time of 102.44 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.843 ns/day, 28.456 hours/ns, 9.762 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.92     | 101.92     | 101.92     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079634   | 0.079634   | 0.079634   |   0.0 |  0.08
Output  | 0.00016386 | 0.00016386 | 0.00016386 |   0.0 |  0.00
Modify  | 0.38365    | 0.38365    | 0.38365    |   0.0 |  0.37
Other   |            | 0.05789    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3108 ave        3108 max        3108 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118822 ave      118822 max      118822 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118822
Ave neighs/atom = 59.411
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.910217254612, Press = -0.219676877332594
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10454.712     -10454.712     -10525.387     -10525.387      273.51949      273.51949      28033.817      28033.817     -183.2062      -183.2062     
     54000  -10458.199     -10458.199     -10529.599     -10529.599      276.32648      276.32648      27976.594      27976.594      2466.8874      2466.8874    
Loop time of 103.032 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.620 hours/ns, 9.706 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.080548   | 0.080548   | 0.080548   |   0.0 |  0.08
Output  | 0.00020179 | 0.00020179 | 0.00020179 |   0.0 |  0.00
Modify  | 0.38546    | 0.38546    | 0.38546    |   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:           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:       118844 ave      118844 max      118844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118844
Ave neighs/atom = 59.422
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.88445368651, Press = -3.13849991167732
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10458.199     -10458.199     -10529.599     -10529.599      276.32648      276.32648      27976.594      27976.594      2466.8874      2466.8874    
     55000  -10453.91      -10453.91      -10524.87      -10524.87       274.62206      274.62206      28063.398      28063.398     -1841.8446     -1841.8446    
Loop time of 103.653 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.793 hours/ns, 9.648 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.13     | 103.13     | 103.13     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080833   | 0.080833   | 0.080833   |   0.0 |  0.08
Output  | 0.00016327 | 0.00016327 | 0.00016327 |   0.0 |  0.00
Modify  | 0.38807    | 0.38807    | 0.38807    |   0.0 |  0.37
Other   |            | 0.05817    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3116 ave        3116 max        3116 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118920 ave      118920 max      118920 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118920
Ave neighs/atom = 59.46
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.898738754437, Press = -0.57748479528084
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10453.91      -10453.91      -10524.87      -10524.87       274.62206      274.62206      28063.398      28063.398     -1841.8446     -1841.8446    
     56000  -10459.657     -10459.657     -10526.684     -10526.684      259.40238      259.40238      27993.685      27993.685      1558.2954      1558.2954    
Loop time of 102.532 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.843 ns/day, 28.481 hours/ns, 9.753 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.01     | 102.01     | 102.01     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080624   | 0.080624   | 0.080624   |   0.0 |  0.08
Output  | 0.00016459 | 0.00016459 | 0.00016459 |   0.0 |  0.00
Modify  | 0.38629    | 0.38629    | 0.38629    |   0.0 |  0.38
Other   |            | 0.05827    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3106 ave        3106 max        3106 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118814 ave      118814 max      118814 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118814
Ave neighs/atom = 59.407
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.882692266662, Press = -1.16916203876339
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10459.657     -10459.657     -10526.684     -10526.684      259.40238      259.40238      27993.685      27993.685      1558.2954      1558.2954    
     57000  -10454.68      -10454.68      -10525.094     -10525.094      272.51203      272.51203      28051.098      28051.098     -1269.6822     -1269.6822    
Loop time of 103.393 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.836 ns/day, 28.720 hours/ns, 9.672 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.080967   | 0.080967   | 0.080967   |   0.0 |  0.08
Output  | 0.00016477 | 0.00016477 | 0.00016477 |   0.0 |  0.00
Modify  | 0.3883     | 0.3883     | 0.3883     |   0.0 |  0.38
Other   |            | 0.0578     |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3120 ave        3120 max        3120 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118876 ave      118876 max      118876 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118876
Ave neighs/atom = 59.438
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.857457368022, Press = -1.16530766186605
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10454.68      -10454.68      -10525.094     -10525.094      272.51203      272.51203      28051.098      28051.098     -1269.6822     -1269.6822    
     58000  -10451.872     -10451.872     -10522.347     -10522.347      272.74519      272.74519      28005.767      28005.767      1444.5113      1444.5113    
Loop time of 102.049 on 1 procs for 1000 steps with 2000 atoms

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

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 101.53     | 101.53     | 101.53     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080012   | 0.080012   | 0.080012   |   0.0 |  0.08
Output  | 0.00020957 | 0.00020957 | 0.00020957 |   0.0 |  0.00
Modify  | 0.38458    | 0.38458    | 0.38458    |   0.0 |  0.38
Other   |            | 0.05787    |            |       |  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:       118808 ave      118808 max      118808 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118808
Ave neighs/atom = 59.404
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.865638722647, Press = -0.540859934247059
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10451.872     -10451.872     -10522.347     -10522.347      272.74519      272.74519      28005.767      28005.767      1444.5113      1444.5113    
     59000  -10455.909     -10455.909     -10524.252     -10524.252      264.49244      264.49244      28056.279      28056.279     -1626.7225     -1626.7225    
Loop time of 102.402 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.844 ns/day, 28.445 hours/ns, 9.765 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.88     | 101.88     | 101.88     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080862   | 0.080862   | 0.080862   |   0.0 |  0.08
Output  | 0.00016357 | 0.00016357 | 0.00016357 |   0.0 |  0.00
Modify  | 0.38351    | 0.38351    | 0.38351    |   0.0 |  0.37
Other   |            | 0.05749    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3152 ave        3152 max        3152 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118928 ave      118928 max      118928 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118928
Ave neighs/atom = 59.464
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.914027776426, Press = -2.46534204205361
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10455.909     -10455.909     -10524.252     -10524.252      264.49244      264.49244      28056.279      28056.279     -1626.7225     -1626.7225    
     60000  -10454.176     -10454.176     -10525.668     -10525.668      276.68171      276.68171      28020.916      28020.916      328.54182      328.54182    
Loop time of 102.504 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.843 ns/day, 28.473 hours/ns, 9.756 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.98     | 101.98     | 101.98     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080028   | 0.080028   | 0.080028   |   0.0 |  0.08
Output  | 0.00016483 | 0.00016483 | 0.00016483 |   0.0 |  0.00
Modify  | 0.38335    | 0.38335    | 0.38335    |   0.0 |  0.37
Other   |            | 0.05847    |            |       |  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:       118794 ave      118794 max      118794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118794
Ave neighs/atom = 59.397
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.910433972498, Press = 0.379186095992648
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10454.176     -10454.176     -10525.668     -10525.668      276.68171      276.68171      28020.916      28020.916      328.54182      328.54182    
     61000  -10453.488     -10453.488     -10524.864     -10524.864      276.2339       276.2339       28023.289      28023.289      266.11661      266.11661    
Loop time of 102.62 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.842 ns/day, 28.506 hours/ns, 9.745 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.09     | 102.09     | 102.09     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080403   | 0.080403   | 0.080403   |   0.0 |  0.08
Output  | 0.00016563 | 0.00016563 | 0.00016563 |   0.0 |  0.00
Modify  | 0.3876     | 0.3876     | 0.3876     |   0.0 |  0.38
Other   |            | 0.05786    |            |       |  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:       118844 ave      118844 max      118844 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118844
Ave neighs/atom = 59.422
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.930785680877, Press = -1.72191339683279
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10453.488     -10453.488     -10524.864     -10524.864      276.2339       276.2339       28023.289      28023.289      266.11661      266.11661    
     62000  -10455.159     -10455.159     -10525.447     -10525.447      272.02169      272.02169      28047.792      28047.792     -1126.6642     -1126.6642    
Loop time of 103.554 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.834 ns/day, 28.765 hours/ns, 9.657 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.02     | 103.02     | 103.02     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081099   | 0.081099   | 0.081099   |   0.0 |  0.08
Output  | 0.00016517 | 0.00016517 | 0.00016517 |   0.0 |  0.00
Modify  | 0.39017    | 0.39017    | 0.39017    |   0.0 |  0.38
Other   |            | 0.0582     |            |       |  0.06

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

Total # of neighbors = 118826
Ave neighs/atom = 59.413
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.929377727229, Press = -0.371340501161771
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10455.159     -10455.159     -10525.447     -10525.447      272.02169      272.02169      28047.792      28047.792     -1126.6642     -1126.6642    
     63000  -10453.973     -10453.973     -10526.007     -10526.007      278.77943      278.77943      27994.084      27994.084      1874.471       1874.471     
Loop time of 101.51 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.851 ns/day, 28.197 hours/ns, 9.851 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        | 101        | 101        |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.079706   | 0.079706   | 0.079706   |   0.0 |  0.08
Output  | 0.00016344 | 0.00016344 | 0.00016344 |   0.0 |  0.00
Modify  | 0.37834    | 0.37834    | 0.37834    |   0.0 |  0.37
Other   |            | 0.057      |            |       |  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:       118754 ave      118754 max      118754 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118754
Ave neighs/atom = 59.377
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 272.987348262757, Press = -1.17829065445359
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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   
     63000  -10453.973     -10453.973     -10526.007     -10526.007      278.77943      278.77943      27994.084      27994.084      1874.471       1874.471     
     64000  -10456.001     -10456.001     -10525.128     -10525.128      267.52774      267.52774      28060.818      28060.818     -1889.6779     -1889.6779    
Loop time of 101.926 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.848 ns/day, 28.313 hours/ns, 9.811 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.41     | 101.41     | 101.41     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.081722   | 0.081722   | 0.081722   |   0.0 |  0.08
Output  | 0.00016502 | 0.00016502 | 0.00016502 |   0.0 |  0.00
Modify  | 0.38073    | 0.38073    | 0.38073    |   0.0 |  0.37
Other   |            | 0.05766    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3192 ave        3192 max        3192 min
Histogram: 1 0 0 0 0 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 = 273.014089528139, Press = -0.858282237140443
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10456.001     -10456.001     -10525.128     -10525.128      267.52774      267.52774      28060.818      28060.818     -1889.6779     -1889.6779    
     65000  -10453.786     -10453.786     -10525.217     -10525.217      276.44606      276.44606      27985.878      27985.878      2267.5569      2267.5569    
Loop time of 101.896 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.848 ns/day, 28.304 hours/ns, 9.814 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.38     | 101.38     | 101.38     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07993    | 0.07993    | 0.07993    |   0.0 |  0.08
Output  | 0.00019783 | 0.00019783 | 0.00019783 |   0.0 |  0.00
Modify  | 0.38237    | 0.38237    | 0.38237    |   0.0 |  0.38
Other   |            | 0.05782    |            |       |  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:       118858 ave      118858 max      118858 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118858
Ave neighs/atom = 59.429
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 273.026102002117, Press = -0.507841769979684
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10453.786     -10453.786     -10525.217     -10525.217      276.44606      276.44606      27985.878      27985.878      2267.5569      2267.5569    
     66000  -10454.505     -10454.505     -10526.623     -10526.623      279.10343      279.10343      28079.726      28079.726     -2953.954      -2953.954     
Loop time of 103.155 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.838 ns/day, 28.654 hours/ns, 9.694 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.63     | 102.63     | 102.63     |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.07992    | 0.07992    | 0.07992    |   0.0 |  0.08
Output  | 0.00016317 | 0.00016317 | 0.00016317 |   0.0 |  0.00
Modify  | 0.38663    | 0.38663    | 0.38663    |   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:           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:       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 = 273.00942128689, Press = -1.86595285868553
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing 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  -10454.505     -10454.505     -10526.623     -10526.623      279.10343      279.10343      28079.726      28079.726     -2953.954      -2953.954     
     67000  -10458.459     -10458.459     -10526.272     -10526.272      262.44531      262.44531      27997.466      27997.466      1309.748       1309.748     
Loop time of 102.934 on 1 procs for 1000 steps with 2000 atoms

Performance: 0.839 ns/day, 28.593 hours/ns, 9.715 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.4      | 102.4      | 102.4      |   0.0 | 99.49
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.080933   | 0.080933   | 0.080933   |   0.0 |  0.08
Output  | 0.00016637 | 0.00016637 | 0.00016637 |   0.0 |  0.00
Modify  | 0.39047    | 0.39047    | 0.39047    |   0.0 |  0.38
Other   |            | 0.05803    |            |       |  0.06

Nlocal:           2000 ave        2000 max        2000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           3102 ave        3102 max        3102 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       118748 ave      118748 max      118748 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 118748
Ave neighs/atom = 59.374
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T273.15.out"  else  "print 'not_converged'  file output/vol_T273.15.out"
print '${V}'  file output/vol_T273.15.out
28026.6110177304

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0