# 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.619999974966049*${_u_distance}
variable latticeconst_converted equal 3.619999974966049*1
lattice       fcc  ${latticeconst_converted}
lattice       fcc  3.61999997496605
Lattice spacing in x,y,z = 3.62 3.62 3.62
region        simbox  block 0 10 0 10 0 10 units lattice
create_box    1 simbox
Created orthogonal box = (0 0 0) to (36.2 36.2 36.2)
  1 by 1 by 1 MPI processor grid
create_atoms  1 box
Created 4000 atoms
  using lattice units in orthogonal box = (0 0 0) to (36.2 36.2 36.2)
  create_atoms CPU = 0.003 seconds

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

kim_interactions Cu

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

kim interactions Cu
#=== BEGIN kim interactions ==================================
pair_style kim MEAM_LAMMPS_EtesamiAsadi_2018_Cu__MO_227887284491_002
pair_coeff * * Cu
#=== END kim interactions ====================================


mass          1 ${mass_converted}
mass          1 63.546

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

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

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

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

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

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

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

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

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

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

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

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

Your simulation uses code contributions which should be cited:

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

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

- OpenKIM potential: https://openkim.org/cite/MO_227887284491_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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
         0  -14008.467     -14008.467     -14160         -14160          293.15         293.15         47437.927      47437.927      3411.9478      3411.9478    
      1000  -13845.487     -13845.487     -13996.629     -13996.629      292.39502      292.39502      48219.858      48219.858     -1098.1714     -1098.1714    
Loop time of 354.583 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.244 ns/day, 98.495 hours/ns, 2.820 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 353.61     | 353.61     | 353.61     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15302    | 0.15302    | 0.15302    |   0.0 |  0.04
Output  | 0.00028093 | 0.00028093 | 0.00028093 |   0.0 |  0.00
Modify  | 0.71454    | 0.71454    | 0.71454    |   0.0 |  0.20
Other   |            | 0.1013     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       312000 ave      312000 max      312000 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 312000
Ave neighs/atom = 78
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      1000  -13845.487     -13845.487     -13996.629     -13996.629      292.39502      292.39502      48219.858      48219.858     -1098.1714     -1098.1714    
      2000  -13858.776     -13858.776     -14006.649     -14006.649      286.07014      286.07014      48107.447      48107.447      905.88067      905.88067    
Loop time of 379.163 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.323 hours/ns, 2.637 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    | 378.16     | 378.16     | 378.16     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15374    | 0.15374    | 0.15374    |   0.0 |  0.04
Output  | 0.00022892 | 0.00022892 | 0.00022892 |   0.0 |  0.00
Modify  | 0.74232    | 0.74232    | 0.74232    |   0.0 |  0.20
Other   |            | 0.1043     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310386 ave      310386 max      310386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310386
Ave neighs/atom = 77.5965
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      2000  -13858.776     -13858.776     -14006.649     -14006.649      286.07014      286.07014      48107.447      48107.447      905.88067      905.88067    
      3000  -13850.098     -13850.098     -14004.713     -14004.713      299.11382      299.11382      48177.026      48177.026     -530.15715     -530.15715    
Loop time of 380.634 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.732 hours/ns, 2.627 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 379.63     | 379.63     | 379.63     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15537    | 0.15537    | 0.15537    |   0.0 |  0.04
Output  | 0.00022916 | 0.00022916 | 0.00022916 |   0.0 |  0.00
Modify  | 0.74374    | 0.74374    | 0.74374    |   0.0 |  0.20
Other   |            | 0.1041     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310794 ave      310794 max      310794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310794
Ave neighs/atom = 77.6985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      3000  -13850.098     -13850.098     -14004.713     -14004.713      299.11382      299.11382      48177.026      48177.026     -530.15715     -530.15715    
      4000  -13858.093     -13858.093     -14006.458     -14006.458      287.02322      287.02322      48125.739      48125.739      420.96345      420.96345    
Loop time of 380.77 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.769 hours/ns, 2.626 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    | 379.77     | 379.77     | 379.77     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15463    | 0.15463    | 0.15463    |   0.0 |  0.04
Output  | 0.00023028 | 0.00023028 | 0.00023028 |   0.0 |  0.00
Modify  | 0.74002    | 0.74002    | 0.74002    |   0.0 |  0.19
Other   |            | 0.104      |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310610 ave      310610 max      310610 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310610
Ave neighs/atom = 77.6525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      4000  -13858.093     -13858.093     -14006.458     -14006.458      287.02322      287.02322      48125.739      48125.739      420.96345      420.96345    
      5000  -13852.098     -13852.098     -14003.529     -14003.529      292.95504      292.95504      48179.04       48179.04      -811.35925     -811.35925    
Loop time of 384.738 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.872 hours/ns, 2.599 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    | 383.73     | 383.73     | 383.73     |   0.0 | 99.74
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15513    | 0.15513    | 0.15513    |   0.0 |  0.04
Output  | 0.00023593 | 0.00023593 | 0.00023593 |   0.0 |  0.00
Modify  | 0.74922    | 0.74922    | 0.74922    |   0.0 |  0.19
Other   |            | 0.1042     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310696 ave      310696 max      310696 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310696
Ave neighs/atom = 77.674
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 298.70668909119, Press = -222.991408736794
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      5000  -13852.098     -13852.098     -14003.529     -14003.529      292.95504      292.95504      48179.04       48179.04      -811.35925     -811.35925    
      6000  -13854.037     -13854.037     -14006.808     -14006.808      295.54544      295.54544      48051.264      48051.264      2676.7337      2676.7337    
Loop time of 383.428 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.508 hours/ns, 2.608 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    | 382.39     | 382.39     | 382.39     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15733    | 0.15733    | 0.15733    |   0.0 |  0.04
Output  | 0.00024624 | 0.00024624 | 0.00024624 |   0.0 |  0.00
Modify  | 0.78051    | 0.78051    | 0.78051    |   0.0 |  0.20
Other   |            | 0.1045     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310396 ave      310396 max      310396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310396
Ave neighs/atom = 77.599
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.985626704184, Press = 18.0973140551083
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      6000  -13854.037     -13854.037     -14006.808     -14006.808      295.54544      295.54544      48051.264      48051.264      2676.7337      2676.7337    
      7000  -13855.946     -13855.946     -14007.559     -14007.559      293.30511      293.30511      48194.429      48194.429     -1516.0071     -1516.0071    
Loop time of 384.713 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.865 hours/ns, 2.599 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    | 383.67     | 383.67     | 383.67     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15606    | 0.15606    | 0.15606    |   0.0 |  0.04
Output  | 0.00018911 | 0.00018911 | 0.00018911 |   0.0 |  0.00
Modify  | 0.78153    | 0.78153    | 0.78153    |   0.0 |  0.20
Other   |            | 0.1039     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310878 ave      310878 max      310878 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310878
Ave neighs/atom = 77.7195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.342703473427, Press = -21.3740497813148
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      7000  -13855.946     -13855.946     -14007.559     -14007.559      293.30511      293.30511      48194.429      48194.429     -1516.0071     -1516.0071    
      8000  -13849.538     -13849.538     -14003.558     -14003.558      297.96227      297.96227      48153.469      48153.469      130.49456      130.49456    
Loop time of 388.376 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 107.882 hours/ns, 2.575 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 387.32     | 387.32     | 387.32     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15837    | 0.15837    | 0.15837    |   0.0 |  0.04
Output  | 0.00024305 | 0.00024305 | 0.00024305 |   0.0 |  0.00
Modify  | 0.79575    | 0.79575    | 0.79575    |   0.0 |  0.20
Other   |            | 0.1054     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310690 ave      310690 max      310690 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310690
Ave neighs/atom = 77.6725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.310651915469, Press = 3.51690176700311
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      8000  -13849.538     -13849.538     -14003.558     -14003.558      297.96227      297.96227      48153.469      48153.469      130.49456      130.49456    
      9000  -13852.758     -13852.758     -14006.164     -14006.164      296.77349      296.77349      48136.71       48136.71       364.29712      364.29712    
Loop time of 383.078 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.411 hours/ns, 2.610 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 382.04     | 382.04     | 382.04     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15587    | 0.15587    | 0.15587    |   0.0 |  0.04
Output  | 0.0001892  | 0.0001892  | 0.0001892  |   0.0 |  0.00
Modify  | 0.77699    | 0.77699    | 0.77699    |   0.0 |  0.20
Other   |            | 0.1042     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310652 ave      310652 max      310652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310652
Ave neighs/atom = 77.663
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.446717348261, Press = -4.09651881970264
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
      9000  -13852.758     -13852.758     -14006.164     -14006.164      296.77349      296.77349      48136.71       48136.71       364.29712      364.29712    
     10000  -13855.296     -13855.296     -14008.339     -14008.339      296.07115      296.07115      48178.202      48178.202     -1091.9465     -1091.9465    
Loop time of 381.234 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.898 hours/ns, 2.623 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    | 380.2      | 380.2      | 380.2      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15645    | 0.15645    | 0.15645    |   0.0 |  0.04
Output  | 0.00019292 | 0.00019292 | 0.00019292 |   0.0 |  0.00
Modify  | 0.77465    | 0.77465    | 0.77465    |   0.0 |  0.20
Other   |            | 0.1038     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310640 ave      310640 max      310640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310640
Ave neighs/atom = 77.66
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.440855337036, Press = -0.898737553694307
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     10000  -13855.296     -13855.296     -14008.339     -14008.339      296.07115      296.07115      48178.202      48178.202     -1091.9465     -1091.9465    
     11000  -13852.385     -13852.385     -14004.181     -14004.181      293.6593       293.6593       48137.492      48137.492      379.14831      379.14831    
Loop time of 390.385 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.440 hours/ns, 2.562 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    | 389.32     | 389.32     | 389.32     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15864    | 0.15864    | 0.15864    |   0.0 |  0.04
Output  | 0.00024057 | 0.00024057 | 0.00024057 |   0.0 |  0.00
Modify  | 0.80215    | 0.80215    | 0.80215    |   0.0 |  0.21
Other   |            | 0.1055     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310652 ave      310652 max      310652 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310652
Ave neighs/atom = 77.663
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.04833135595, Press = -1.81022590005063
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     11000  -13852.385     -13852.385     -14004.181     -14004.181      293.6593       293.6593       48137.492      48137.492      379.14831      379.14831    
     12000  -13856.423     -13856.423     -14008.173     -14008.173      293.5713       293.5713       48152.678      48152.678     -425.31813     -425.31813    
Loop time of 389.909 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.308 hours/ns, 2.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    | 388.84     | 388.84     | 388.84     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15873    | 0.15873    | 0.15873    |   0.0 |  0.04
Output  | 0.00023024 | 0.00023024 | 0.00023024 |   0.0 |  0.00
Modify  | 0.80457    | 0.80457    | 0.80457    |   0.0 |  0.21
Other   |            | 0.1062     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310656 ave      310656 max      310656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310656
Ave neighs/atom = 77.664
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.01764670283, Press = 0.489906488241801
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     12000  -13856.423     -13856.423     -14008.173     -14008.173      293.5713       293.5713       48152.678      48152.678     -425.31813     -425.31813    
     13000  -13849.686     -13849.686     -14003.079     -14003.079      296.74988      296.74988      48136.923      48136.923      590.89722      590.89722    
Loop time of 381.642 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.012 hours/ns, 2.620 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    | 380.6      | 380.6      | 380.6      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15652    | 0.15652    | 0.15652    |   0.0 |  0.04
Output  | 0.00023769 | 0.00023769 | 0.00023769 |   0.0 |  0.00
Modify  | 0.778      | 0.778      | 0.778      |   0.0 |  0.20
Other   |            | 0.1042     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310708 ave      310708 max      310708 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310708
Ave neighs/atom = 77.677
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.086548879522, Press = -0.584201362451811
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     13000  -13849.686     -13849.686     -14003.079     -14003.079      296.74988      296.74988      48136.923      48136.923      590.89722      590.89722    
     14000  -13855.203     -13855.203     -14006.851     -14006.851      293.37293      293.37293      48188.148      48188.148     -1310.6217     -1310.6217    
Loop time of 383.777 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.605 hours/ns, 2.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    | 382.73     | 382.73     | 382.73     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15647    | 0.15647    | 0.15647    |   0.0 |  0.04
Output  | 0.00161    | 0.00161    | 0.00161    |   0.0 |  0.00
Modify  | 0.77995    | 0.77995    | 0.77995    |   0.0 |  0.20
Other   |            | 0.1042     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310530 ave      310530 max      310530 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310530
Ave neighs/atom = 77.6325
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.222862746955, Press = -1.77280989290085
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     14000  -13855.203     -13855.203     -14006.851     -14006.851      293.37293      293.37293      48188.148      48188.148     -1310.6217     -1310.6217    
     15000  -13854.268     -13854.268     -14005.82      -14005.82       293.18727      293.18727      48104.494      48104.494      1184.1142      1184.1142    
Loop time of 387.005 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.501 hours/ns, 2.584 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    | 385.96     | 385.96     | 385.96     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.157      | 0.157      | 0.157      |   0.0 |  0.04
Output  | 0.00024976 | 0.00024976 | 0.00024976 |   0.0 |  0.00
Modify  | 0.7882     | 0.7882     | 0.7882     |   0.0 |  0.20
Other   |            | 0.1045     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310616 ave      310616 max      310616 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310616
Ave neighs/atom = 77.654
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.181618700473, Press = 4.53136034516866
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     15000  -13854.268     -13854.268     -14005.82      -14005.82       293.18727      293.18727      48104.494      48104.494      1184.1142      1184.1142    
     16000  -13858.986     -13858.986     -14008.092     -14008.092      288.45713      288.45713      48159.843      48159.843     -727.4891      -727.4891     
Loop time of 386.271 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.298 hours/ns, 2.589 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    | 385.22     | 385.22     | 385.22     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15676    | 0.15676    | 0.15676    |   0.0 |  0.04
Output  | 0.00023712 | 0.00023712 | 0.00023712 |   0.0 |  0.00
Modify  | 0.78717    | 0.78717    | 0.78717    |   0.0 |  0.20
Other   |            | 0.1045     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310548 ave      310548 max      310548 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310548
Ave neighs/atom = 77.637
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.161829443443, Press = -6.15465511272104
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     16000  -13858.986     -13858.986     -14008.092     -14008.092      288.45713      288.45713      48159.843      48159.843     -727.4891      -727.4891     
     17000  -13852.42      -13852.42      -14003.363     -14003.363      292.01043      292.01043      48144.413      48144.413      214.00871      214.00871    
Loop time of 380.036 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.566 hours/ns, 2.631 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    | 379.01     | 379.01     | 379.01     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1549     | 0.1549     | 0.1549     |   0.0 |  0.04
Output  | 0.00030992 | 0.00030992 | 0.00030992 |   0.0 |  0.00
Modify  | 0.76719    | 0.76719    | 0.76719    |   0.0 |  0.20
Other   |            | 0.1036     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310676 ave      310676 max      310676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310676
Ave neighs/atom = 77.669
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.122900321997, Press = 1.54337408837167
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     17000  -13852.42      -13852.42      -14003.363     -14003.363      292.01043      292.01043      48144.413      48144.413      214.00871      214.00871    
     18000  -13856.353     -13856.353     -14008.659     -14008.659      294.64719      294.64719      48119.397      48119.397      477.08971      477.08971    
Loop time of 381.507 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 105.974 hours/ns, 2.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    | 380.47     | 380.47     | 380.47     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15645    | 0.15645    | 0.15645    |   0.0 |  0.04
Output  | 0.0001883  | 0.0001883  | 0.0001883  |   0.0 |  0.00
Modify  | 0.7733     | 0.7733     | 0.7733     |   0.0 |  0.20
Other   |            | 0.1034     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310522 ave      310522 max      310522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310522
Ave neighs/atom = 77.6305
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 292.974593623456, Press = -1.59902690038609
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     18000  -13856.353     -13856.353     -14008.659     -14008.659      294.64719      294.64719      48119.397      48119.397      477.08971      477.08971    
     19000  -13853.767     -13853.767     -14006.208     -14006.208      294.90775      294.90775      48190.494      48190.494     -1368.0921     -1368.0921    
Loop time of 382.424 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.229 hours/ns, 2.615 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 381.38     | 381.38     | 381.38     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15693    | 0.15693    | 0.15693    |   0.0 |  0.04
Output  | 0.00019174 | 0.00019174 | 0.00019174 |   0.0 |  0.00
Modify  | 0.78354    | 0.78354    | 0.78354    |   0.0 |  0.20
Other   |            | 0.1048     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310820 ave      310820 max      310820 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310820
Ave neighs/atom = 77.705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.011153403245, Press = -0.530061417465665
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     19000  -13853.767     -13853.767     -14006.208     -14006.208      294.90775      294.90775      48190.494      48190.494     -1368.0921     -1368.0921    
     20000  -13849.583     -13849.583     -14005.52      -14005.52       301.66988      301.66988      48111.676      48111.676      1152.8374      1152.8374    
Loop time of 384.185 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.718 hours/ns, 2.603 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    | 383.14     | 383.14     | 383.14     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15702    | 0.15702    | 0.15702    |   0.0 |  0.04
Output  | 0.00018793 | 0.00018793 | 0.00018793 |   0.0 |  0.00
Modify  | 0.782      | 0.782      | 0.782      |   0.0 |  0.20
Other   |            | 0.1048     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310470 ave      310470 max      310470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310470
Ave neighs/atom = 77.6175
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.090037185225, Press = 0.233012406960232
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     20000  -13849.583     -13849.583     -14005.52      -14005.52       301.66988      301.66988      48111.676      48111.676      1152.8374      1152.8374    
     21000  -13855.733     -13855.733     -14008.392     -14008.392      295.32891      295.32891      48212.975      48212.975     -2236.1549     -2236.1549    
Loop time of 380.135 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.593 hours/ns, 2.631 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    | 379.11     | 379.11     | 379.11     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1547     | 0.1547     | 0.1547     |   0.0 |  0.04
Output  | 0.00018988 | 0.00018988 | 0.00018988 |   0.0 |  0.00
Modify  | 0.76624    | 0.76624    | 0.76624    |   0.0 |  0.20
Other   |            | 0.104      |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310666 ave      310666 max      310666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310666
Ave neighs/atom = 77.6665
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.203562744515, Press = -1.91051065088977
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     21000  -13855.733     -13855.733     -14008.392     -14008.392      295.32891      295.32891      48212.975      48212.975     -2236.1549     -2236.1549    
     22000  -13856.454     -13856.454     -14008.321     -14008.321      293.79748      293.79748      48047.879      48047.879      2642.8784      2642.8784    
Loop time of 386.38 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.328 hours/ns, 2.588 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    | 385.33     | 385.33     | 385.33     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15757    | 0.15757    | 0.15757    |   0.0 |  0.04
Output  | 0.00025375 | 0.00025375 | 0.00025375 |   0.0 |  0.00
Modify  | 0.78851    | 0.78851    | 0.78851    |   0.0 |  0.20
Other   |            | 0.1045     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310614 ave      310614 max      310614 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310614
Ave neighs/atom = 77.6535
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.260947006781, Press = 1.87948897420037
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     22000  -13856.454     -13856.454     -14008.321     -14008.321      293.79748      293.79748      48047.879      48047.879      2642.8784      2642.8784    
     23000  -13855.29      -13855.29      -14006.003     -14006.003      291.56555      291.56555      48179.971      48179.971     -1082.2367     -1082.2367    
Loop time of 388.413 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 107.893 hours/ns, 2.575 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    | 387.36     | 387.36     | 387.36     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15815    | 0.15815    | 0.15815    |   0.0 |  0.04
Output  | 0.00025852 | 0.00025852 | 0.00025852 |   0.0 |  0.00
Modify  | 0.79211    | 0.79211    | 0.79211    |   0.0 |  0.20
Other   |            | 0.1049     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310854 ave      310854 max      310854 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310854
Ave neighs/atom = 77.7135
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.27990594729, Press = -2.3062193154677
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     23000  -13855.29      -13855.29      -14006.003     -14006.003      291.56555      291.56555      48179.971      48179.971     -1082.2367     -1082.2367    
     24000  -13850.007     -13850.007     -14000.342     -14000.342      290.83341      290.83341      48120.27       48120.27       1279.7111      1279.7111    
Loop time of 383.74 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.594 hours/ns, 2.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    | 382.7      | 382.7      | 382.7      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15545    | 0.15545    | 0.15545    |   0.0 |  0.04
Output  | 0.00019537 | 0.00019537 | 0.00019537 |   0.0 |  0.00
Modify  | 0.7843     | 0.7843     | 0.7843     |   0.0 |  0.20
Other   |            | 0.1047     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310552 ave      310552 max      310552 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310552
Ave neighs/atom = 77.638
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.290466702924, Press = 1.23508149818218
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     24000  -13850.007     -13850.007     -14000.342     -14000.342      290.83341      290.83341      48120.27       48120.27       1279.7111      1279.7111    
     25000  -13854.271     -13854.271     -14007.047     -14007.047      295.55535      295.55535      48165.527      48165.527     -654.05661     -654.05661    
Loop time of 384.083 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.690 hours/ns, 2.604 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    | 383.04     | 383.04     | 383.04     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1564     | 0.1564     | 0.1564     |   0.0 |  0.04
Output  | 0.000191   | 0.000191   | 0.000191   |   0.0 |  0.00
Modify  | 0.78285    | 0.78285    | 0.78285    |   0.0 |  0.20
Other   |            | 0.1046     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310498 ave      310498 max      310498 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310498
Ave neighs/atom = 77.6245
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.397063345804, Press = -2.1872584387911
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     25000  -13854.271     -13854.271     -14007.047     -14007.047      295.55535      295.55535      48165.527      48165.527     -654.05661     -654.05661    
     26000  -13851.634     -13851.634     -14004.821     -14004.821      296.35101      296.35101      48146.536      48146.536      131.27649      131.27649    
Loop time of 384.988 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 106.941 hours/ns, 2.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    | 383.94     | 383.94     | 383.94     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15688    | 0.15688    | 0.15688    |   0.0 |  0.04
Output  | 0.00019027 | 0.00019027 | 0.00019027 |   0.0 |  0.00
Modify  | 0.78765    | 0.78765    | 0.78765    |   0.0 |  0.20
Other   |            | 0.1048     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310654 ave      310654 max      310654 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310654
Ave neighs/atom = 77.6635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.417037120988, Press = 1.27294865153845
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     26000  -13851.634     -13851.634     -14004.821     -14004.821      296.35101      296.35101      48146.536      48146.536      131.27649      131.27649    
     27000  -13855.777     -13855.777     -14006.211     -14006.211      291.0253       291.0253       48128.861      48128.861      485.58112      485.58112    
Loop time of 389.904 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.307 hours/ns, 2.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    | 388.84     | 388.84     | 388.84     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15948    | 0.15948    | 0.15948    |   0.0 |  0.04
Output  | 0.00024679 | 0.00024679 | 0.00024679 |   0.0 |  0.00
Modify  | 0.79905    | 0.79905    | 0.79905    |   0.0 |  0.20
Other   |            | 0.1057     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310598 ave      310598 max      310598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310598
Ave neighs/atom = 77.6495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.470790940224, Press = -2.74960662263077
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     27000  -13855.777     -13855.777     -14006.211     -14006.211      291.0253       291.0253       48128.861      48128.861      485.58112      485.58112    
     28000  -13852.547     -13852.547     -14006.758     -14006.758      298.33195      298.33195      48203.588      48203.588     -1653.6326     -1653.6326    
Loop time of 385.724 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.145 hours/ns, 2.593 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    | 384.68     | 384.68     | 384.68     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1565     | 0.1565     | 0.1565     |   0.0 |  0.04
Output  | 0.00019149 | 0.00019149 | 0.00019149 |   0.0 |  0.00
Modify  | 0.7807     | 0.7807     | 0.7807     |   0.0 |  0.20
Other   |            | 0.1041     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310728 ave      310728 max      310728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310728
Ave neighs/atom = 77.682
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.481945572049, Press = 1.1027916987143
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     28000  -13852.547     -13852.547     -14006.758     -14006.758      298.33195      298.33195      48203.588      48203.588     -1653.6326     -1653.6326    
     29000  -13853.76      -13853.76      -14006.422     -14006.422      295.33569      295.33569      48113.552      48113.552      953.81912      953.81912    
Loop time of 385.024 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 106.951 hours/ns, 2.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    | 383.97     | 383.97     | 383.97     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15749    | 0.15749    | 0.15749    |   0.0 |  0.04
Output  | 0.00019162 | 0.00019162 | 0.00019162 |   0.0 |  0.00
Modify  | 0.79095    | 0.79095    | 0.79095    |   0.0 |  0.21
Other   |            | 0.1045     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310720 ave      310720 max      310720 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310720
Ave neighs/atom = 77.68
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.536642291001, Press = -0.727943538803747
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     29000  -13853.76      -13853.76      -14006.422     -14006.422      295.33569      295.33569      48113.552      48113.552      953.81912      953.81912    
     30000  -13855.652     -13855.652     -14007.627     -14007.627      294.00567      294.00567      48173.796      48173.796     -961.75692     -961.75692    
Loop time of 382.275 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.188 hours/ns, 2.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    | 381.25     | 381.25     | 381.25     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15528    | 0.15528    | 0.15528    |   0.0 |  0.04
Output  | 0.00023072 | 0.00023072 | 0.00023072 |   0.0 |  0.00
Modify  | 0.77031    | 0.77031    | 0.77031    |   0.0 |  0.20
Other   |            | 0.104      |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310716 ave      310716 max      310716 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310716
Ave neighs/atom = 77.679
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.567837653595, Press = -0.408154439621878
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     30000  -13855.652     -13855.652     -14007.627     -14007.627      294.00567      294.00567      48173.796      48173.796     -961.75692     -961.75692    
     31000  -13853.931     -13853.931     -14006.485     -14006.485      295.1257       295.1257       48136.136      48136.136      257.19125      257.19125    
Loop time of 383.536 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.538 hours/ns, 2.607 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    | 382.5      | 382.5      | 382.5      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15465    | 0.15465    | 0.15465    |   0.0 |  0.04
Output  | 0.00023287 | 0.00023287 | 0.00023287 |   0.0 |  0.00
Modify  | 0.77744    | 0.77744    | 0.77744    |   0.0 |  0.20
Other   |            | 0.1041     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310562 ave      310562 max      310562 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310562
Ave neighs/atom = 77.6405
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.583689575074, Press = -0.220007834057356
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     31000  -13853.931     -13853.931     -14006.485     -14006.485      295.1257       295.1257       48136.136      48136.136      257.19125      257.19125    
     32000  -13859.379     -13859.379     -14007.515     -14007.515      286.57934      286.57934      48140.159      48140.159      25.988968      25.988968    
Loop time of 391.34 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.221 ns/day, 108.706 hours/ns, 2.555 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    | 390.27     | 390.27     | 390.27     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15886    | 0.15886    | 0.15886    |   0.0 |  0.04
Output  | 0.00023513 | 0.00023513 | 0.00023513 |   0.0 |  0.00
Modify  | 0.80097    | 0.80097    | 0.80097    |   0.0 |  0.20
Other   |            | 0.1058     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310682 ave      310682 max      310682 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310682
Ave neighs/atom = 77.6705
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.521772270158, Press = 0.0876973894942969
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     32000  -13859.379     -13859.379     -14007.515     -14007.515      286.57934      286.57934      48140.159      48140.159      25.988968      25.988968    
     33000  -13852.601     -13852.601     -14005.055     -14005.055      294.93226      294.93226      48162.351      48162.351     -326.70489     -326.70489    
Loop time of 388.41 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 107.892 hours/ns, 2.575 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 387.35     | 387.35     | 387.35     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15855    | 0.15855    | 0.15855    |   0.0 |  0.04
Output  | 0.00022877 | 0.00022877 | 0.00022877 |   0.0 |  0.00
Modify  | 0.79726    | 0.79726    | 0.79726    |   0.0 |  0.21
Other   |            | 0.1051     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310756 ave      310756 max      310756 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310756
Ave neighs/atom = 77.689
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.473106686999, Press = -1.85130529067884
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     33000  -13852.601     -13852.601     -14005.055     -14005.055      294.93226      294.93226      48162.351      48162.351     -326.70489     -326.70489    
     34000  -13850.725     -13850.725     -14002.839     -14002.839      294.27464      294.27464      48190.584      48190.584     -846.34805     -846.34805    
Loop time of 385.499 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.083 hours/ns, 2.594 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    | 384.45     | 384.45     | 384.45     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15817    | 0.15817    | 0.15817    |   0.0 |  0.04
Output  | 0.0001896  | 0.0001896  | 0.0001896  |   0.0 |  0.00
Modify  | 0.78743    | 0.78743    | 0.78743    |   0.0 |  0.20
Other   |            | 0.1052     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310706 ave      310706 max      310706 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310706
Ave neighs/atom = 77.6765
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.460204047577, Press = 0.710247593321947
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     34000  -13850.725     -13850.725     -14002.839     -14002.839      294.27464      294.27464      48190.584      48190.584     -846.34805     -846.34805    
     35000  -13853.354     -13853.354     -14007.582     -14007.582      298.36355      298.36355      48074.285      48074.285      1941.2907      1941.2907    
Loop time of 384.195 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.721 hours/ns, 2.603 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    | 383.16     | 383.16     | 383.16     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15666    | 0.15666    | 0.15666    |   0.0 |  0.04
Output  | 0.00018922 | 0.00018922 | 0.00018922 |   0.0 |  0.00
Modify  | 0.77744    | 0.77744    | 0.77744    |   0.0 |  0.20
Other   |            | 0.1048     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310520 ave      310520 max      310520 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310520
Ave neighs/atom = 77.63
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.460479603157, Press = -1.16837760255501
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     35000  -13853.354     -13853.354     -14007.582     -14007.582      298.36355      298.36355      48074.285      48074.285      1941.2907      1941.2907    
     36000  -13857.894     -13857.894     -14006.36      -14006.36       287.21899      287.21899      48180.119      48180.119     -1132.6064     -1132.6064    
Loop time of 392.382 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.220 ns/day, 108.995 hours/ns, 2.549 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 391.31     | 391.31     | 391.31     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15933    | 0.15933    | 0.15933    |   0.0 |  0.04
Output  | 0.00026449 | 0.00026449 | 0.00026449 |   0.0 |  0.00
Modify  | 0.80963    | 0.80963    | 0.80963    |   0.0 |  0.21
Other   |            | 0.1071     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310818 ave      310818 max      310818 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310818
Ave neighs/atom = 77.7045
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.438142700433, Press = -0.552556091361146
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     36000  -13857.894     -13857.894     -14006.36      -14006.36       287.21899      287.21899      48180.119      48180.119     -1132.6064     -1132.6064    
     37000  -13852.125     -13852.125     -14004.859     -14004.859      295.47408      295.47408      48131.943      48131.943      594.16396      594.16396    
Loop time of 385.517 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.088 hours/ns, 2.594 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    | 384.46     | 384.46     | 384.46     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15651    | 0.15651    | 0.15651    |   0.0 |  0.04
Output  | 0.00019126 | 0.00019126 | 0.00019126 |   0.0 |  0.00
Modify  | 0.7914     | 0.7914     | 0.7914     |   0.0 |  0.21
Other   |            | 0.1049     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310622 ave      310622 max      310622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310622
Ave neighs/atom = 77.6555
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.409583747947, Press = -0.161238079831494
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     37000  -13852.125     -13852.125     -14004.859     -14004.859      295.47408      295.47408      48131.943      48131.943      594.16396      594.16396    
     38000  -13854.399     -13854.399     -14005.923     -14005.923      293.13358      293.13358      48163.936      48163.936     -587.08821     -587.08821    
Loop time of 379.77 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.492 hours/ns, 2.633 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    | 378.74     | 378.74     | 378.74     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1547     | 0.1547     | 0.1547     |   0.0 |  0.04
Output  | 0.00023175 | 0.00023175 | 0.00023175 |   0.0 |  0.00
Modify  | 0.77065    | 0.77065    | 0.77065    |   0.0 |  0.20
Other   |            | 0.1031     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310728 ave      310728 max      310728 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310728
Ave neighs/atom = 77.682
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.462961265581, Press = -0.217850791450242
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     38000  -13854.399     -13854.399     -14005.923     -14005.923      293.13358      293.13358      48163.936      48163.936     -587.08821     -587.08821    
     39000  -13853.817     -13853.817     -14004.564     -14004.564      291.63007      291.63007      48111.388      48111.388      1141.8266      1141.8266    
Loop time of 380.843 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.790 hours/ns, 2.626 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    | 379.81     | 379.81     | 379.81     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15368    | 0.15368    | 0.15368    |   0.0 |  0.04
Output  | 0.00019141 | 0.00019141 | 0.00019141 |   0.0 |  0.00
Modify  | 0.77686    | 0.77686    | 0.77686    |   0.0 |  0.20
Other   |            | 0.1031     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310620 ave      310620 max      310620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310620
Ave neighs/atom = 77.655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.459366957721, Press = -0.287584427688341
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     39000  -13853.817     -13853.817     -14004.564     -14004.564      291.63007      291.63007      48111.388      48111.388      1141.8266      1141.8266    
     40000  -13855.216     -13855.216     -14005.575     -14005.575      290.88045      290.88045      48187.664      48187.664     -1189.0705     -1189.0705    
Loop time of 382.832 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.342 hours/ns, 2.612 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    | 381.8      | 381.8      | 381.8      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15408    | 0.15408    | 0.15408    |   0.0 |  0.04
Output  | 0.00019398 | 0.00019398 | 0.00019398 |   0.0 |  0.00
Modify  | 0.77683    | 0.77683    | 0.77683    |   0.0 |  0.20
Other   |            | 0.1039     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310736 ave      310736 max      310736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310736
Ave neighs/atom = 77.684
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.448561311113, Press = -0.790629439753337
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     40000  -13855.216     -13855.216     -14005.575     -14005.575      290.88045      290.88045      48187.664      48187.664     -1189.0705     -1189.0705    
     41000  -13855.496     -13855.496     -14005.693     -14005.693      290.56598      290.56598      48075.956      48075.956      2046.8426      2046.8426    
Loop time of 378.971 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.270 hours/ns, 2.639 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    | 377.95     | 377.95     | 377.95     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15266    | 0.15266    | 0.15266    |   0.0 |  0.04
Output  | 0.00026397 | 0.00026397 | 0.00026397 |   0.0 |  0.00
Modify  | 0.76316    | 0.76316    | 0.76316    |   0.0 |  0.20
Other   |            | 0.1024     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310564 ave      310564 max      310564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310564
Ave neighs/atom = 77.641
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.458740463375, Press = 1.14267944500806
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     41000  -13855.496     -13855.496     -14005.693     -14005.693      290.56598      290.56598      48075.956      48075.956      2046.8426      2046.8426    
     42000  -13850.337     -13850.337     -14003.408     -14003.408      296.12712      296.12712      48176.423      48176.423     -637.0177      -637.0177     
Loop time of 379.293 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.359 hours/ns, 2.636 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 378.27     | 378.27     | 378.27     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15346    | 0.15346    | 0.15346    |   0.0 |  0.04
Output  | 0.00018984 | 0.00018984 | 0.00018984 |   0.0 |  0.00
Modify  | 0.7664     | 0.7664     | 0.7664     |   0.0 |  0.20
Other   |            | 0.1027     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310790 ave      310790 max      310790 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310790
Ave neighs/atom = 77.6975
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.491085858316, Press = -1.24276761498604
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     42000  -13850.337     -13850.337     -14003.408     -14003.408      296.12712      296.12712      48176.423      48176.423     -637.0177      -637.0177     
     43000  -13854.641     -13854.641     -14005.111     -14005.111      291.09456      291.09456      48142.398      48142.398      240.07689      240.07689    
Loop time of 379.211 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.336 hours/ns, 2.637 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    | 378.19     | 378.19     | 378.19     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15145    | 0.15145    | 0.15145    |   0.0 |  0.04
Output  | 0.00023964 | 0.00023964 | 0.00023964 |   0.0 |  0.00
Modify  | 0.76332    | 0.76332    | 0.76332    |   0.0 |  0.20
Other   |            | 0.1034     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310444 ave      310444 max      310444 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310444
Ave neighs/atom = 77.611
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.491069068248, Press = 0.163461480393957
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     43000  -13854.641     -13854.641     -14005.111     -14005.111      291.09456      291.09456      48142.398      48142.398      240.07689      240.07689    
     44000  -13857.017     -13857.017     -14004.482     -14004.482      285.28097      285.28097      48135.843      48135.843      411.7215       411.7215     
Loop time of 381.618 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.005 hours/ns, 2.620 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    | 380.58     | 380.58     | 380.58     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15399    | 0.15399    | 0.15399    |   0.0 |  0.04
Output  | 0.00019184 | 0.00019184 | 0.00019184 |   0.0 |  0.00
Modify  | 0.77684    | 0.77684    | 0.77684    |   0.0 |  0.20
Other   |            | 0.1035     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310680 ave      310680 max      310680 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310680
Ave neighs/atom = 77.67
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.509254848014, Press = -0.874399548796314
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     44000  -13857.017     -13857.017     -14004.482     -14004.482      285.28097      285.28097      48135.843      48135.843      411.7215       411.7215     
     45000  -13852.982     -13852.982     -14003.501     -14003.501      291.18896      291.18896      48136.041      48136.041      551.81804      551.81804    
Loop time of 381.609 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.003 hours/ns, 2.620 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    | 380.58     | 380.58     | 380.58     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15385    | 0.15385    | 0.15385    |   0.0 |  0.04
Output  | 0.00019043 | 0.00019043 | 0.00019043 |   0.0 |  0.00
Modify  | 0.77667    | 0.77667    | 0.77667    |   0.0 |  0.20
Other   |            | 0.1033     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310558 ave      310558 max      310558 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310558
Ave neighs/atom = 77.6395
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.486831994518, Press = 0.715808140455063
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     45000  -13852.982     -13852.982     -14003.501     -14003.501      291.18896      291.18896      48136.041      48136.041      551.81804      551.81804    
     46000  -13851.55      -13851.55      -14006.674     -14006.674      300.09953      300.09953      48129.407      48129.407      447.99674      447.99674    
Loop time of 381.335 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.926 hours/ns, 2.622 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    | 380.31     | 380.31     | 380.31     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15336    | 0.15336    | 0.15336    |   0.0 |  0.04
Output  | 0.0001913  | 0.0001913  | 0.0001913  |   0.0 |  0.00
Modify  | 0.77315    | 0.77315    | 0.77315    |   0.0 |  0.20
Other   |            | 0.1031     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310564 ave      310564 max      310564 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310564
Ave neighs/atom = 77.641
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.509413743654, Press = -2.11293979203937
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     46000  -13851.55      -13851.55      -14006.674     -14006.674      300.09953      300.09953      48129.407      48129.407      447.99674      447.99674    
     47000  -13851.163     -13851.163     -14004.217     -14004.217      296.09284      296.09284      48189.074      48189.074     -1043.2558     -1043.2558    
Loop time of 382.928 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.369 hours/ns, 2.611 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    | 381.9      | 381.9      | 381.9      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15367    | 0.15367    | 0.15367    |   0.0 |  0.04
Output  | 0.00023798 | 0.00023798 | 0.00023798 |   0.0 |  0.00
Modify  | 0.77227    | 0.77227    | 0.77227    |   0.0 |  0.20
Other   |            | 0.1025     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310660 ave      310660 max      310660 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310660
Ave neighs/atom = 77.665
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.508614310838, Press = 0.871156948560592
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     47000  -13851.163     -13851.163     -14004.217     -14004.217      296.09284      296.09284      48189.074      48189.074     -1043.2558     -1043.2558    
     48000  -13855.956     -13855.956     -14005.029     -14005.029      288.39215      288.39215      48116.522      48116.522      909.34958      909.34958    
Loop time of 381.094 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.860 hours/ns, 2.624 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    | 380.06     | 380.06     | 380.06     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15413    | 0.15413    | 0.15413    |   0.0 |  0.04
Output  | 0.0001908  | 0.0001908  | 0.0001908  |   0.0 |  0.00
Modify  | 0.7713     | 0.7713     | 0.7713     |   0.0 |  0.20
Other   |            | 0.1037     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310518 ave      310518 max      310518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310518
Ave neighs/atom = 77.6295
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.47368508841, Press = -0.251912759412899
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     48000  -13855.956     -13855.956     -14005.029     -14005.029      288.39215      288.39215      48116.522      48116.522      909.34958      909.34958    
     49000  -13854.857     -13854.857     -14006.345     -14006.345      293.0638       293.0638       48135.915      48135.915      191.26257      191.26257    
Loop time of 381.655 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.015 hours/ns, 2.620 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    | 380.62     | 380.62     | 380.62     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15376    | 0.15376    | 0.15376    |   0.0 |  0.04
Output  | 0.00019018 | 0.00019018 | 0.00019018 |   0.0 |  0.00
Modify  | 0.77384    | 0.77384    | 0.77384    |   0.0 |  0.20
Other   |            | 0.103      |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310622 ave      310622 max      310622 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310622
Ave neighs/atom = 77.6555
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.441491167428, Press = -0.331521732350325
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     49000  -13854.857     -13854.857     -14006.345     -14006.345      293.0638       293.0638       48135.915      48135.915      191.26257      191.26257    
     50000  -13852.412     -13852.412     -14003.284     -14003.284      291.87163      291.87163      48160.329      48160.329     -81.682164     -81.682164    
Loop time of 376.656 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.627 hours/ns, 2.655 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    | 375.64     | 375.64     | 375.64     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15153    | 0.15153    | 0.15153    |   0.0 |  0.04
Output  | 0.0001887  | 0.0001887  | 0.0001887  |   0.0 |  0.00
Modify  | 0.76016    | 0.76016    | 0.76016    |   0.0 |  0.20
Other   |            | 0.103      |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310630 ave      310630 max      310630 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310630
Ave neighs/atom = 77.6575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.425135004853, Press = -0.455137749931367
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     50000  -13852.412     -13852.412     -14003.284     -14003.284      291.87163      291.87163      48160.329      48160.329     -81.682164     -81.682164    
     51000  -13853.178     -13853.178     -14006.647     -14006.647      296.89481      296.89481      48176.755      48176.755     -953.47664     -953.47664    
Loop time of 370.998 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 103.055 hours/ns, 2.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    | 369.99     | 369.99     | 369.99     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15026    | 0.15026    | 0.15026    |   0.0 |  0.04
Output  | 0.00019082 | 0.00019082 | 0.00019082 |   0.0 |  0.00
Modify  | 0.75195    | 0.75195    | 0.75195    |   0.0 |  0.20
Other   |            | 0.1021     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310546 ave      310546 max      310546 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310546
Ave neighs/atom = 77.6365
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.414363842168, Press = 0.79602770999995
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     51000  -13853.178     -13853.178     -14006.647     -14006.647      296.89481      296.89481      48176.755      48176.755     -953.47664     -953.47664    
     52000  -13855.113     -13855.113     -14007.662     -14007.662      295.11614      295.11614      48104.269      48104.269      1056.5352      1056.5352    
Loop time of 370.067 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 102.796 hours/ns, 2.702 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    | 369.07     | 369.07     | 369.07     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14941    | 0.14941    | 0.14941    |   0.0 |  0.04
Output  | 0.00046294 | 0.00046294 | 0.00046294 |   0.0 |  0.00
Modify  | 0.74439    | 0.74439    | 0.74439    |   0.0 |  0.20
Other   |            | 0.1018     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310496 ave      310496 max      310496 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310496
Ave neighs/atom = 77.624
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.373489451932, Press = -0.676485828623974
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     52000  -13855.113     -13855.113     -14007.662     -14007.662      295.11614      295.11614      48104.269      48104.269      1056.5352      1056.5352    
     53000  -13848.147     -13848.147     -14002.343     -14002.343      298.30183      298.30183      48211.993      48211.993     -1487.7106     -1487.7106    
Loop time of 389.888 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.222 ns/day, 108.302 hours/ns, 2.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    | 388.83     | 388.83     | 388.83     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15659    | 0.15659    | 0.15659    |   0.0 |  0.04
Output  | 0.00019403 | 0.00019403 | 0.00019403 |   0.0 |  0.00
Modify  | 0.79589    | 0.79589    | 0.79589    |   0.0 |  0.20
Other   |            | 0.1049     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310700 ave      310700 max      310700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310700
Ave neighs/atom = 77.675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.403014167187, Press = -0.114343407420658
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     53000  -13848.147     -13848.147     -14002.343     -14002.343      298.30183      298.30183      48211.993      48211.993     -1487.7106     -1487.7106    
     54000  -13856.309     -13856.309     -14007.624     -14007.624      292.73036      292.73036      48104.702      48104.702      1024.936       1024.936     
Loop time of 377.439 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.844 hours/ns, 2.649 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    | 376.42     | 376.42     | 376.42     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15233    | 0.15233    | 0.15233    |   0.0 |  0.04
Output  | 0.00019089 | 0.00019089 | 0.00019089 |   0.0 |  0.00
Modify  | 0.76854    | 0.76854    | 0.76854    |   0.0 |  0.20
Other   |            | 0.1024     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310516 ave      310516 max      310516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310516
Ave neighs/atom = 77.629
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.407786580289, Press = -0.374429130138384
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     54000  -13856.309     -13856.309     -14007.624     -14007.624      292.73036      292.73036      48104.702      48104.702      1024.936       1024.936     
     55000  -13849.25      -13849.25      -14005.917     -14005.917      303.08115      303.08115      48211.582      48211.582     -1761.5299     -1761.5299    
Loop time of 383.875 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.632 hours/ns, 2.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    | 382.83     | 382.83     | 382.83     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15436    | 0.15436    | 0.15436    |   0.0 |  0.04
Output  | 0.00027155 | 0.00027155 | 0.00027155 |   0.0 |  0.00
Modify  | 0.78262    | 0.78262    | 0.78262    |   0.0 |  0.20
Other   |            | 0.1044     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310698 ave      310698 max      310698 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310698
Ave neighs/atom = 77.6745
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.438094861987, Press = -0.528577321771712
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     55000  -13849.25      -13849.25      -14005.917     -14005.917      303.08115      303.08115      48211.582      48211.582     -1761.5299     -1761.5299    
     56000  -13856.614     -13856.614     -14009.37      -14009.37       295.5162       295.5162       48118.257      48118.257      463.46426      463.46426    
Loop time of 374.936 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.149 hours/ns, 2.667 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 373.93     | 373.93     | 373.93     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15072    | 0.15072    | 0.15072    |   0.0 |  0.04
Output  | 0.00018913 | 0.00018913 | 0.00018913 |   0.0 |  0.00
Modify  | 0.74885    | 0.74885    | 0.74885    |   0.0 |  0.20
Other   |            | 0.1022     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310432 ave      310432 max      310432 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310432
Ave neighs/atom = 77.608
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.450971907197, Press = -0.351323839740116
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     56000  -13856.614     -13856.614     -14009.37      -14009.37       295.5162       295.5162       48118.257      48118.257      463.46426      463.46426    
     57000  -13852.439     -13852.439     -14002.197     -14002.197      289.71554      289.71554      48194.94       48194.94      -960.31597     -960.31597    
Loop time of 375.93 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.425 hours/ns, 2.660 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    | 374.92     | 374.92     | 374.92     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15178    | 0.15178    | 0.15178    |   0.0 |  0.04
Output  | 0.00023358 | 0.00023358 | 0.00023358 |   0.0 |  0.00
Modify  | 0.75699    | 0.75699    | 0.75699    |   0.0 |  0.20
Other   |            | 0.1024     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310736 ave      310736 max      310736 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310736
Ave neighs/atom = 77.684
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.457919120714, Press = -0.226339023852377
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     57000  -13852.439     -13852.439     -14002.197     -14002.197      289.71554      289.71554      48194.94       48194.94      -960.31597     -960.31597    
     58000  -13858.624     -13858.624     -14012.048     -14012.048      296.80968      296.80968      48095.438      48095.438      833.8186       833.8186     
Loop time of 387.304 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.584 hours/ns, 2.582 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    | 386.25     | 386.25     | 386.25     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15608    | 0.15608    | 0.15608    |   0.0 |  0.04
Output  | 0.00018966 | 0.00018966 | 0.00018966 |   0.0 |  0.00
Modify  | 0.78996    | 0.78996    | 0.78996    |   0.0 |  0.20
Other   |            | 0.1047     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310606 ave      310606 max      310606 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310606
Ave neighs/atom = 77.6515
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.45277725648, Press = 0.264716282734978
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     58000  -13858.624     -13858.624     -14012.048     -14012.048      296.80968      296.80968      48095.438      48095.438      833.8186       833.8186     
     59000  -13851.202     -13851.202     -14006.038     -14006.038      299.54117      299.54117      48185.667      48185.667     -1083.7166     -1083.7166    
Loop time of 379.898 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.527 hours/ns, 2.632 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 378.87     | 378.87     | 378.87     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15411    | 0.15411    | 0.15411    |   0.0 |  0.04
Output  | 0.00019021 | 0.00019021 | 0.00019021 |   0.0 |  0.00
Modify  | 0.77554    | 0.77554    | 0.77554    |   0.0 |  0.20
Other   |            | 0.1033     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310922 ave      310922 max      310922 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310922
Ave neighs/atom = 77.7305
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.437983224552, Press = -1.31049773195186
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     59000  -13851.202     -13851.202     -14006.038     -14006.038      299.54117      299.54117      48185.667      48185.667     -1083.7166     -1083.7166    
     60000  -13852.302     -13852.302     -14005.377     -14005.377      296.13424      296.13424      48136.338      48136.338      185.13319      185.13319    
Loop time of 381.076 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.854 hours/ns, 2.624 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    | 380.04     | 380.04     | 380.04     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15326    | 0.15326    | 0.15326    |   0.0 |  0.04
Output  | 0.00023547 | 0.00023547 | 0.00023547 |   0.0 |  0.00
Modify  | 0.77764    | 0.77764    | 0.77764    |   0.0 |  0.20
Other   |            | 0.1038     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310628 ave      310628 max      310628 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310628
Ave neighs/atom = 77.657
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.429864602972, Press = 0.754585322874955
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     60000  -13852.302     -13852.302     -14005.377     -14005.377      296.13424      296.13424      48136.338      48136.338      185.13319      185.13319    
     61000  -13854.105     -13854.105     -14005.113     -14005.113      292.13528      292.13528      48150.118      48150.118     -18.518796     -18.518796    
Loop time of 376.395 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.554 hours/ns, 2.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    | 375.38     | 375.38     | 375.38     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15204    | 0.15204    | 0.15204    |   0.0 |  0.04
Output  | 0.00024277 | 0.00024277 | 0.00024277 |   0.0 |  0.00
Modify  | 0.76019    | 0.76019    | 0.76019    |   0.0 |  0.20
Other   |            | 0.1029     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310644 ave      310644 max      310644 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310644
Ave neighs/atom = 77.661
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.415674217293, Press = -0.666934481993364
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     61000  -13854.105     -13854.105     -14005.113     -14005.113      292.13528      292.13528      48150.118      48150.118     -18.518796     -18.518796    
     62000  -13858.015     -13858.015     -14008.284     -14008.284      290.70591      290.70591      48161.582      48161.582     -773.22789     -773.22789    
Loop time of 375.529 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.314 hours/ns, 2.663 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    | 374.51     | 374.51     | 374.51     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15048    | 0.15048    | 0.15048    |   0.0 |  0.04
Output  | 0.00019155 | 0.00019155 | 0.00019155 |   0.0 |  0.00
Modify  | 0.76195    | 0.76195    | 0.76195    |   0.0 |  0.20
Other   |            | 0.1029     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310578 ave      310578 max      310578 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310578
Ave neighs/atom = 77.6445
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.4008515652, Press = 0.112301747918512
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     62000  -13858.015     -13858.015     -14008.284     -14008.284      290.70591      290.70591      48161.582      48161.582     -773.22789     -773.22789    
     63000  -13853.223     -13853.223     -14005.815     -14005.815      295.19851      295.19851      48112.259      48112.259      979.85134      979.85134    
Loop time of 378.2 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.055 hours/ns, 2.644 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    | 377.17     | 377.17     | 377.17     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15345    | 0.15345    | 0.15345    |   0.0 |  0.04
Output  | 0.00023921 | 0.00023921 | 0.00023921 |   0.0 |  0.00
Modify  | 0.77108    | 0.77108    | 0.77108    |   0.0 |  0.20
Other   |            | 0.1035     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310598 ave      310598 max      310598 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310598
Ave neighs/atom = 77.6495
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.38591096798, Press = -0.259713055032794
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     63000  -13853.223     -13853.223     -14005.815     -14005.815      295.19851      295.19851      48112.259      48112.259      979.85134      979.85134    
     64000  -13857.192     -13857.192     -14006.79      -14006.79       289.40856      289.40856      48265.641      48265.641     -3621.1975     -3621.1975    
Loop time of 385.32 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.033 hours/ns, 2.595 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    | 384.27     | 384.27     | 384.27     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15439    | 0.15439    | 0.15439    |   0.0 |  0.04
Output  | 0.00023987 | 0.00023987 | 0.00023987 |   0.0 |  0.00
Modify  | 0.78638    | 0.78638    | 0.78638    |   0.0 |  0.20
Other   |            | 0.1043     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310624 ave      310624 max      310624 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310624
Ave neighs/atom = 77.656
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.383628416132, Press = -0.679148291144486
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     64000  -13857.192     -13857.192     -14006.79      -14006.79       289.40856      289.40856      48265.641      48265.641     -3621.1975     -3621.1975    
     65000  -13852.999     -13852.999     -14006.263     -14006.263      296.49993      296.49993      48069.576      48069.576      2174.3147      2174.3147    
Loop time of 386.889 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.469 hours/ns, 2.585 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    | 385.84     | 385.84     | 385.84     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15641    | 0.15641    | 0.15641    |   0.0 |  0.04
Output  | 0.00019573 | 0.00019573 | 0.00019573 |   0.0 |  0.00
Modify  | 0.78812    | 0.78812    | 0.78812    |   0.0 |  0.20
Other   |            | 0.1053     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310478 ave      310478 max      310478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310478
Ave neighs/atom = 77.6195
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.38697472903, Press = 0.447340275286531
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     65000  -13852.999     -13852.999     -14006.263     -14006.263      296.49993      296.49993      48069.576      48069.576      2174.3147      2174.3147    
     66000  -13852.154     -13852.154     -14004.167     -14004.167      294.07968      294.07968      48179.464      48179.464     -678.06726     -678.06726    
Loop time of 384.062 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.684 hours/ns, 2.604 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    | 383.01     | 383.01     | 383.01     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15588    | 0.15588    | 0.15588    |   0.0 |  0.04
Output  | 0.00019744 | 0.00019744 | 0.00019744 |   0.0 |  0.00
Modify  | 0.79001    | 0.79001    | 0.79001    |   0.0 |  0.21
Other   |            | 0.1045     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310718 ave      310718 max      310718 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310718
Ave neighs/atom = 77.6795
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.383807841449, Press = -0.708690085182388
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     66000  -13852.154     -13852.154     -14004.167     -14004.167      294.07968      294.07968      48179.464      48179.464     -678.06726     -678.06726    
     67000  -13852.132     -13852.132     -14006.266     -14006.266      298.18381      298.18381      48158.172      48158.172     -339.0315      -339.0315     
Loop time of 370.17 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 102.825 hours/ns, 2.701 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    | 369.18     | 369.18     | 369.18     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14922    | 0.14922    | 0.14922    |   0.0 |  0.04
Output  | 0.00022856 | 0.00022856 | 0.00022856 |   0.0 |  0.00
Modify  | 0.74372    | 0.74372    | 0.74372    |   0.0 |  0.20
Other   |            | 0.1019     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310700 ave      310700 max      310700 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310700
Ave neighs/atom = 77.675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.418765691199, Press = 0.445191141179021
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     67000  -13852.132     -13852.132     -14006.266     -14006.266      298.18381      298.18381      48158.172      48158.172     -339.0315      -339.0315     
     68000  -13855.594     -13855.594     -14007.28      -14007.28       293.44641      293.44641      48112.225      48112.225      762.75346      762.75346    
Loop time of 384.18 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.225 ns/day, 106.717 hours/ns, 2.603 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    | 383.14     | 383.14     | 383.14     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15508    | 0.15508    | 0.15508    |   0.0 |  0.04
Output  | 0.00021091 | 0.00021091 | 0.00021091 |   0.0 |  0.00
Modify  | 0.78294    | 0.78294    | 0.78294    |   0.0 |  0.20
Other   |            | 0.1057     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310590 ave      310590 max      310590 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310590
Ave neighs/atom = 77.6475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.430292186116, Press = -0.400411772023946
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     68000  -13855.594     -13855.594     -14007.28      -14007.28       293.44641      293.44641      48112.225      48112.225      762.75346      762.75346    
     69000  -13854.364     -13854.364     -14003.337     -14003.337      288.19845      288.19845      48168.109      48168.109     -336.68844     -336.68844    
Loop time of 387.138 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.223 ns/day, 107.538 hours/ns, 2.583 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    | 386.09     | 386.09     | 386.09     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15681    | 0.15681    | 0.15681    |   0.0 |  0.04
Output  | 0.00022695 | 0.00022695 | 0.00022695 |   0.0 |  0.00
Modify  | 0.78891    | 0.78891    | 0.78891    |   0.0 |  0.20
Other   |            | 0.1054     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310684 ave      310684 max      310684 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310684
Ave neighs/atom = 77.671
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.439411463293, Press = 0.162290534108852
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     69000  -13854.364     -13854.364     -14003.337     -14003.337      288.19845      288.19845      48168.109      48168.109     -336.68844     -336.68844    
     70000  -13857.907     -13857.907     -14007.003     -14007.003      288.43619      288.43619      48110.673      48110.673      814.44045      814.44045    
Loop time of 378.761 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.212 hours/ns, 2.640 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    | 377.74     | 377.74     | 377.74     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15408    | 0.15408    | 0.15408    |   0.0 |  0.04
Output  | 0.00018911 | 0.00018911 | 0.00018911 |   0.0 |  0.00
Modify  | 0.76675    | 0.76675    | 0.76675    |   0.0 |  0.20
Other   |            | 0.1035     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310560 ave      310560 max      310560 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310560
Ave neighs/atom = 77.64
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.437840261662, Press = -0.572177063607406
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     70000  -13857.907     -13857.907     -14007.003     -14007.003      288.43619      288.43619      48110.673      48110.673      814.44045      814.44045    
     71000  -13851.584     -13851.584     -14006.14      -14006.14       298.99924      298.99924      48198.029      48198.029     -1549.675      -1549.675     
Loop time of 379.205 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.335 hours/ns, 2.637 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    | 378.18     | 378.18     | 378.18     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15279    | 0.15279    | 0.15279    |   0.0 |  0.04
Output  | 0.0001901  | 0.0001901  | 0.0001901  |   0.0 |  0.00
Modify  | 0.76892    | 0.76892    | 0.76892    |   0.0 |  0.20
Other   |            | 0.1032     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310704 ave      310704 max      310704 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310704
Ave neighs/atom = 77.676
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.440587097674, Press = 0.133062555836987
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     71000  -13851.584     -13851.584     -14006.14      -14006.14       298.99924      298.99924      48198.029      48198.029     -1549.675      -1549.675     
     72000  -13851.763     -13851.763     -14004.066     -14004.066      294.64088      294.64088      48078.164      48078.164      2329.694       2329.694     
Loop time of 377.943 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.984 hours/ns, 2.646 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    | 376.92     | 376.92     | 376.92     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15298    | 0.15298    | 0.15298    |   0.0 |  0.04
Output  | 0.00019878 | 0.00019878 | 0.00019878 |   0.0 |  0.00
Modify  | 0.76588    | 0.76588    | 0.76588    |   0.0 |  0.20
Other   |            | 0.1035     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310452 ave      310452 max      310452 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310452
Ave neighs/atom = 77.613
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.433450897573, Press = -0.257061214304703
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     72000  -13851.763     -13851.763     -14004.066     -14004.066      294.64088      294.64088      48078.164      48078.164      2329.694       2329.694     
     73000  -13856.514     -13856.514     -14009.483     -14009.483      295.93019      295.93019      48218.349      48218.349     -2455.6426     -2455.6426    
Loop time of 381.412 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.227 ns/day, 105.948 hours/ns, 2.622 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    | 380.37     | 380.37     | 380.37     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15426    | 0.15426    | 0.15426    |   0.0 |  0.04
Output  | 0.00018858 | 0.00018858 | 0.00018858 |   0.0 |  0.00
Modify  | 0.77948    | 0.77948    | 0.77948    |   0.0 |  0.20
Other   |            | 0.1045     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310828 ave      310828 max      310828 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310828
Ave neighs/atom = 77.707
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.455827591951, Press = -0.562455665299963
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     73000  -13856.514     -13856.514     -14009.483     -14009.483      295.93019      295.93019      48218.349      48218.349     -2455.6426     -2455.6426    
     74000  -13850.257     -13850.257     -14003.494     -14003.494      296.44794      296.44794      48130.889      48130.889      652.51974      652.51974    
Loop time of 377.439 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.844 hours/ns, 2.649 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    | 376.42     | 376.42     | 376.42     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15162    | 0.15162    | 0.15162    |   0.0 |  0.04
Output  | 0.00019087 | 0.00019087 | 0.00019087 |   0.0 |  0.00
Modify  | 0.76259    | 0.76259    | 0.76259    |   0.0 |  0.20
Other   |            | 0.1035     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310516 ave      310516 max      310516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310516
Ave neighs/atom = 77.629
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.473641747958, Press = 0.191500581576699
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     74000  -13850.257     -13850.257     -14003.494     -14003.494      296.44794      296.44794      48130.889      48130.889      652.51974      652.51974    
     75000  -13851.028     -13851.028     -14005.947     -14005.947      299.70121      299.70121      48149.168      48149.168     -28.626035     -28.626035    
Loop time of 377.293 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.804 hours/ns, 2.650 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 376.27     | 376.27     | 376.27     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15231    | 0.15231    | 0.15231    |   0.0 |  0.04
Output  | 0.0002415  | 0.0002415  | 0.0002415  |   0.0 |  0.00
Modify  | 0.76603    | 0.76603    | 0.76603    |   0.0 |  0.20
Other   |            | 0.1036     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310528 ave      310528 max      310528 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310528
Ave neighs/atom = 77.632
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.470989476309, Press = -0.34388380365024
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     75000  -13851.028     -13851.028     -14005.947     -14005.947      299.70121      299.70121      48149.168      48149.168     -28.626035     -28.626035    
     76000  -13856.93      -13856.93      -14009.955     -14009.955      296.0373       296.0373       48171.864      48171.864     -1181.066      -1181.066     
Loop time of 385.648 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.224 ns/day, 107.124 hours/ns, 2.593 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    | 384.6      | 384.6      | 384.6      |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15567    | 0.15567    | 0.15567    |   0.0 |  0.04
Output  | 0.0002615  | 0.0002615  | 0.0002615  |   0.0 |  0.00
Modify  | 0.78981    | 0.78981    | 0.78981    |   0.0 |  0.20
Other   |            | 0.1046     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310620 ave      310620 max      310620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310620
Ave neighs/atom = 77.655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.483761598275, Press = 0.0230608993179241
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     76000  -13856.93      -13856.93      -14009.955     -14009.955      296.0373       296.0373       48171.864      48171.864     -1181.066      -1181.066     
     77000  -13856.328     -13856.328     -14007.053     -14007.053      291.58792      291.58792      48087.234      48087.234      1462.4644      1462.4644    
Loop time of 369.741 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.706 hours/ns, 2.705 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 368.74     | 368.74     | 368.74     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15051    | 0.15051    | 0.15051    |   0.0 |  0.04
Output  | 0.0002396  | 0.0002396  | 0.0002396  |   0.0 |  0.00
Modify  | 0.74438    | 0.74438    | 0.74438    |   0.0 |  0.20
Other   |            | 0.1018     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310656 ave      310656 max      310656 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310656
Ave neighs/atom = 77.664
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.482469749951, Press = -0.558907856403098
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     77000  -13856.328     -13856.328     -14007.053     -14007.053      291.58792      291.58792      48087.234      48087.234      1462.4644      1462.4644    
     78000  -13854.5       -13854.5       -14005.692     -14005.692      292.49091      292.49091      48231.907      48231.907     -2484.6325     -2484.6325    
Loop time of 378.405 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.228 ns/day, 105.112 hours/ns, 2.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    | 377.38     | 377.38     | 377.38     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1519     | 0.1519     | 0.1519     |   0.0 |  0.04
Output  | 0.00019087 | 0.00019087 | 0.00019087 |   0.0 |  0.00
Modify  | 0.7709     | 0.7709     | 0.7709     |   0.0 |  0.20
Other   |            | 0.1039     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310638 ave      310638 max      310638 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310638
Ave neighs/atom = 77.6595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.446839795873, Press = 0.346664970212585
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     78000  -13854.5       -13854.5       -14005.692     -14005.692      292.49091      292.49091      48231.907      48231.907     -2484.6325     -2484.6325    
     79000  -13858.267     -13858.267     -14006.898     -14006.898      287.53681      287.53681      48086.648      48086.648      1565.9211      1565.9211    
Loop time of 368.792 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.442 hours/ns, 2.712 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 367.79     | 367.79     | 367.79     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14989    | 0.14989    | 0.14989    |   0.0 |  0.04
Output  | 0.0001909  | 0.0001909  | 0.0001909  |   0.0 |  0.00
Modify  | 0.74825    | 0.74825    | 0.74825    |   0.0 |  0.20
Other   |            | 0.103      |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310398 ave      310398 max      310398 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310398
Ave neighs/atom = 77.5995
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.43724552997, Press = -0.165477845115686
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     79000  -13858.267     -13858.267     -14006.898     -14006.898      287.53681      287.53681      48086.648      48086.648      1565.9211      1565.9211    
     80000  -13850.659     -13850.659     -14001.524     -14001.524      291.85768      291.85768      48177.928      48177.928     -462.83173     -462.83173    
Loop time of 369.84 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.733 hours/ns, 2.704 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    | 368.83     | 368.83     | 368.83     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15102    | 0.15102    | 0.15102    |   0.0 |  0.04
Output  | 0.00019089 | 0.00019089 | 0.00019089 |   0.0 |  0.00
Modify  | 0.75352    | 0.75352    | 0.75352    |   0.0 |  0.20
Other   |            | 0.1033     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310666 ave      310666 max      310666 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310666
Ave neighs/atom = 77.6665
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.414586728917, Press = -0.0324152885237823
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     80000  -13850.659     -13850.659     -14001.524     -14001.524      291.85768      291.85768      48177.928      48177.928     -462.83173     -462.83173    
     81000  -13855.625     -13855.625     -14006.915     -14006.915      292.67987      292.67987      48121.985      48121.985      605.33915      605.33915    
Loop time of 370.134 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.233 ns/day, 102.815 hours/ns, 2.702 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    | 369.14     | 369.14     | 369.14     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14916    | 0.14916    | 0.14916    |   0.0 |  0.04
Output  | 0.00019351 | 0.00019351 | 0.00019351 |   0.0 |  0.00
Modify  | 0.74542    | 0.74542    | 0.74542    |   0.0 |  0.20
Other   |            | 0.102      |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310518 ave      310518 max      310518 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310518
Ave neighs/atom = 77.6295
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.429672733396, Press = -0.128153835334186
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     81000  -13855.625     -13855.625     -14006.915     -14006.915      292.67987      292.67987      48121.985      48121.985      605.33915      605.33915    
     82000  -13848.908     -13848.908     -14003.753     -14003.753      299.55697      299.55697      48224.061      48224.061     -1937.8303     -1937.8303    
Loop time of 376.097 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.471 hours/ns, 2.659 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 375.08     | 375.08     | 375.08     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15234    | 0.15234    | 0.15234    |   0.0 |  0.04
Output  | 0.00018983 | 0.00018983 | 0.00018983 |   0.0 |  0.00
Modify  | 0.75836    | 0.75836    | 0.75836    |   0.0 |  0.20
Other   |            | 0.1027     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310676 ave      310676 max      310676 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310676
Ave neighs/atom = 77.669
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.440176347572, Press = -0.326182346148203
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     82000  -13848.908     -13848.908     -14003.753     -14003.753      299.55697      299.55697      48224.061      48224.061     -1937.8303     -1937.8303    
     83000  -13854.322     -13854.322     -14008.706     -14008.706      298.66638      298.66638      48039.242      48039.242      2838.029       2838.029     
Loop time of 377.589 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.229 ns/day, 104.886 hours/ns, 2.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    | 376.56     | 376.56     | 376.56     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15254    | 0.15254    | 0.15254    |   0.0 |  0.04
Output  | 0.00019287 | 0.00019287 | 0.00019287 |   0.0 |  0.00
Modify  | 0.76846    | 0.76846    | 0.76846    |   0.0 |  0.20
Other   |            | 0.1041     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310486 ave      310486 max      310486 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310486
Ave neighs/atom = 77.6215
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.4325857618, Press = 0.405761490289605
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     83000  -13854.322     -13854.322     -14008.706     -14008.706      298.66638      298.66638      48039.242      48039.242      2838.029       2838.029     
     84000  -13856.817     -13856.817     -14005.447     -14005.447      287.53458      287.53458      48182.105      48182.105     -1037.6079     -1037.6079    
Loop time of 376.358 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.544 hours/ns, 2.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    | 375.34     | 375.34     | 375.34     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15172    | 0.15172    | 0.15172    |   0.0 |  0.04
Output  | 0.0001906  | 0.0001906  | 0.0001906  |   0.0 |  0.00
Modify  | 0.76553    | 0.76553    | 0.76553    |   0.0 |  0.20
Other   |            | 0.1034     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310794 ave      310794 max      310794 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310794
Ave neighs/atom = 77.6985
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.415083349025, Press = -0.403686893731852
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     84000  -13856.817     -13856.817     -14005.447     -14005.447      287.53458      287.53458      48182.105      48182.105     -1037.6079     -1037.6079    
     85000  -13857.858     -13857.858     -14006.553     -14006.553      287.66139      287.66139      48127.871      48127.871      344.25304      344.25304    
Loop time of 382.314 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.226 ns/day, 106.198 hours/ns, 2.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    | 381.27     | 381.27     | 381.27     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15477    | 0.15477    | 0.15477    |   0.0 |  0.04
Output  | 0.00024299 | 0.00024299 | 0.00024299 |   0.0 |  0.00
Modify  | 0.7824     | 0.7824     | 0.7824     |   0.0 |  0.20
Other   |            | 0.1042     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310592 ave      310592 max      310592 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310592
Ave neighs/atom = 77.648
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.374459776848, Press = 0.37747363000928
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     85000  -13857.858     -13857.858     -14006.553     -14006.553      287.66139      287.66139      48127.871      48127.871      344.25304      344.25304    
     86000  -13852.472     -13852.472     -14004.864     -14004.864      294.81309      294.81309      48126.47       48126.47       650.27672      650.27672    
Loop time of 373.427 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.231 ns/day, 103.730 hours/ns, 2.678 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    | 372.42     | 372.42     | 372.42     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15161    | 0.15161    | 0.15161    |   0.0 |  0.04
Output  | 0.00018817 | 0.00018817 | 0.00018817 |   0.0 |  0.00
Modify  | 0.75544    | 0.75544    | 0.75544    |   0.0 |  0.20
Other   |            | 0.1024     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310640 ave      310640 max      310640 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310640
Ave neighs/atom = 77.66
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.374301746148, Press = -0.486312294907606
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     86000  -13852.472     -13852.472     -14004.864     -14004.864      294.81309      294.81309      48126.47       48126.47       650.27672      650.27672    
     87000  -13856.465     -13856.465     -14007.608     -14007.608      292.3962       292.3962       48172.651      48172.651     -1011.677      -1011.677     
Loop time of 375.201 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.230 ns/day, 104.223 hours/ns, 2.665 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    | 374.19     | 374.19     | 374.19     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15255    | 0.15255    | 0.15255    |   0.0 |  0.04
Output  | 0.0001888  | 0.0001888  | 0.0001888  |   0.0 |  0.00
Modify  | 0.75588    | 0.75588    | 0.75588    |   0.0 |  0.20
Other   |            | 0.1031     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310582 ave      310582 max      310582 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310582
Ave neighs/atom = 77.6455
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.366292397001, Press = 0.200309554687549
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     87000  -13856.465     -13856.465     -14007.608     -14007.608      292.3962       292.3962       48172.651      48172.651     -1011.677      -1011.677     
     88000  -13854.512     -13854.512     -14005.656     -14005.656      292.39882      292.39882      48118.102      48118.102      820.93383      820.93383    
Loop time of 362.136 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.239 ns/day, 100.593 hours/ns, 2.761 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 361.16     | 361.16     | 361.16     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14691    | 0.14691    | 0.14691    |   0.0 |  0.04
Output  | 0.00023073 | 0.00023073 | 0.00023073 |   0.0 |  0.00
Modify  | 0.72328    | 0.72328    | 0.72328    |   0.0 |  0.20
Other   |            | 0.1003     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310642 ave      310642 max      310642 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310642
Ave neighs/atom = 77.6605
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.352045315511, Press = -0.239787881060338
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     88000  -13854.512     -13854.512     -14005.656     -14005.656      292.39882      292.39882      48118.102      48118.102      820.93383      820.93383    
     89000  -13850.839     -13850.839     -14002.542     -14002.542      293.47986      293.47986      48168.149      48168.149     -381.65101     -381.65101    
Loop time of 367.056 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.235 ns/day, 101.960 hours/ns, 2.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    | 366.06     | 366.06     | 366.06     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14982    | 0.14982    | 0.14982    |   0.0 |  0.04
Output  | 0.00019102 | 0.00019102 | 0.00019102 |   0.0 |  0.00
Modify  | 0.73959    | 0.73959    | 0.73959    |   0.0 |  0.20
Other   |            | 0.1021     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310620 ave      310620 max      310620 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 310620
Ave neighs/atom = 77.655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 293.341038685566, Press = -0.34776942888861
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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 = 13 13 13
  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) = 4.613 | 4.613 | 4.613 Mbytes
   Step         TotEng     v_etotal_metal     PotEng       v_pe_metal        Temp        v_T_metal        Volume       v_V_metal        Press        v_P_metal   
     89000  -13850.839     -13850.839     -14002.542     -14002.542      293.47986      293.47986      48168.149      48168.149     -381.65101     -381.65101    
     90000  -13854.99      -13854.99      -14009.865     -14009.865      299.61704      299.61704      48138.86       48138.86      -157.42435     -157.42435    
Loop time of 368.542 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.234 ns/day, 102.373 hours/ns, 2.713 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 367.55     | 367.55     | 367.55     |   0.0 | 99.73
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14937    | 0.14937    | 0.14937    |   0.0 |  0.04
Output  | 0.0012801  | 0.0012801  | 0.0012801  |   0.0 |  0.00
Modify  | 0.74047    | 0.74047    | 0.74047    |   0.0 |  0.20
Other   |            | 0.1014     |            |       |  0.03

Nlocal:           4000 ave        4000 max        4000 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Nghost:           5841 ave        5841 max        5841 min
Histogram: 1 0 0 0 0 0 0 0 0 0
Neighs:              0 ave           0 max           0 min
Histogram: 1 0 0 0 0 0 0 0 0 0
FullNghs:       310310 ave      310310 max      310310 min
Histogram: 1 0 0 0 0 0 0 0 0 0

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

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

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0