# 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_Wagner_2007_Cu__MO_313717476091_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 333.15*${_u_temperature}
variable temp_converted equal 333.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 333.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 333.15 ${temp_converted} ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 ${Tdamp_converted}               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso ${press_converted} ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 ${press_converted} ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.15 0.1               iso 0 0 ${Pdamp_converted}
fix           ensemble all npt temp 333.15 333.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  "333.15 - 0.2"
variable      T_up  equal  "333.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_313717476091_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  -13987.791     -13987.791     -14160         -14160          333.15         333.15         47437.927      47437.927      3877.4978      3877.4978    
      1000  -13848.287     -13848.287     -14017.807     -14017.807      327.94896      327.94896      47756.743      47756.743      2513.5308      2513.5308    
Loop time of 195.212 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.443 ns/day, 54.226 hours/ns, 5.123 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    | 194.31     | 194.31     | 194.31     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14503    | 0.14503    | 0.14503    |   0.0 |  0.07
Output  | 0.00024346 | 0.00024346 | 0.00024346 |   0.0 |  0.00
Modify  | 0.65769    | 0.65769    | 0.65769    |   0.0 |  0.34
Other   |            | 0.09757    |            |       |  0.05

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  -13848.287     -13848.287     -14017.807     -14017.807      327.94896      327.94896      47756.743      47756.743      2513.5308      2513.5308    
      2000  -13836.665     -13836.665     -14011.165     -14011.165      337.58302      337.58302      47826.434      47826.434      461.6382       461.6382     
Loop time of 200.251 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.625 hours/ns, 4.994 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    | 199.37     | 199.37     | 199.37     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14039    | 0.14039    | 0.14039    |   0.0 |  0.07
Output  | 0.00023657 | 0.00023657 | 0.00023657 |   0.0 |  0.00
Modify  | 0.63914    | 0.63914    | 0.63914    |   0.0 |  0.32
Other   |            | 0.09744    |            |       |  0.05

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:       311540 ave      311540 max      311540 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311540
Ave neighs/atom = 77.885
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -13836.665     -13836.665     -14011.165     -14011.165      337.58302      337.58302      47826.434      47826.434      461.6382       461.6382     
      3000  -13839.293     -13839.293     -14009.93      -14009.93       330.1091       330.1091       47838.279      47838.279      60.74245       60.74245     
Loop time of 200.247 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.624 hours/ns, 4.994 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    | 199.37     | 199.37     | 199.37     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14157    | 0.14157    | 0.14157    |   0.0 |  0.07
Output  | 0.00028998 | 0.00028998 | 0.00028998 |   0.0 |  0.00
Modify  | 0.63834    | 0.63834    | 0.63834    |   0.0 |  0.32
Other   |            | 0.09799    |            |       |  0.05

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:       311430 ave      311430 max      311430 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311430
Ave neighs/atom = 77.8575
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -13839.293     -13839.293     -14009.93      -14009.93       330.1091       330.1091       47838.279      47838.279      60.74245       60.74245     
      4000  -13845.455     -13845.455     -14016.613     -14016.613      331.11636      331.11636      47878.918      47878.918     -1321.3514     -1321.3514    
Loop time of 200.646 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.735 hours/ns, 4.984 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    | 199.76     | 199.76     | 199.76     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14144    | 0.14144    | 0.14144    |   0.0 |  0.07
Output  | 0.00028091 | 0.00028091 | 0.00028091 |   0.0 |  0.00
Modify  | 0.64357    | 0.64357    | 0.64357    |   0.0 |  0.32
Other   |            | 0.09767    |            |       |  0.05

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:       311386 ave      311386 max      311386 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311386
Ave neighs/atom = 77.8465
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${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  -13845.455     -13845.455     -14016.613     -14016.613      331.11636      331.11636      47878.918      47878.918     -1321.3514     -1321.3514    
      5000  -13842.284     -13842.284     -14014.476     -14014.476      333.11838      333.11838      47858.99       47858.99      -870.4789      -870.4789     
Loop time of 200.567 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.713 hours/ns, 4.986 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    | 199.68     | 199.68     | 199.68     |   0.0 | 99.56
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14193    | 0.14193    | 0.14193    |   0.0 |  0.07
Output  | 0.00019228 | 0.00019228 | 0.00019228 |   0.0 |  0.00
Modify  | 0.64569    | 0.64569    | 0.64569    |   0.0 |  0.32
Other   |            | 0.0964     |            |       |  0.05

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:       311420 ave      311420 max      311420 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311420
Ave neighs/atom = 77.855
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.598285147558, Press = -196.40244746076
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13842.284     -13842.284     -14014.476     -14014.476      333.11838      333.11838      47858.99       47858.99      -870.4789      -870.4789     
      6000  -13837.951     -13837.951     -14012.831     -14012.831      338.31767      338.31767      47848.228      47848.228     -219.11877     -219.11877    
Loop time of 200.444 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.679 hours/ns, 4.989 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    | 199.53     | 199.53     | 199.53     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14244    | 0.14244    | 0.14244    |   0.0 |  0.07
Output  | 0.0001946  | 0.0001946  | 0.0001946  |   0.0 |  0.00
Modify  | 0.66936    | 0.66936    | 0.66936    |   0.0 |  0.33
Other   |            | 0.09716    |            |       |  0.05

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:       311348 ave      311348 max      311348 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311348
Ave neighs/atom = 77.837
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.832533080182, Press = -40.7247066060427
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13837.951     -13837.951     -14012.831     -14012.831      338.31767      338.31767      47848.228      47848.228     -219.11877     -219.11877    
      7000  -13838.056     -13838.056     -14013.025     -14013.025      338.48941      338.48941      47819.344      47819.344      702.65241      702.65241    
Loop time of 201.857 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.071 hours/ns, 4.954 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    | 200.95     | 200.95     | 200.95     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14586    | 0.14586    | 0.14586    |   0.0 |  0.07
Output  | 0.0002437  | 0.0002437  | 0.0002437  |   0.0 |  0.00
Modify  | 0.67148    | 0.67148    | 0.67148    |   0.0 |  0.33
Other   |            | 0.09447    |            |       |  0.05

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:       311376 ave      311376 max      311376 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311376
Ave neighs/atom = 77.844
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 332.961551614257, Press = -21.6043210738479
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13838.056     -13838.056     -14013.025     -14013.025      338.48941      338.48941      47819.344      47819.344      702.65241      702.65241    
      8000  -13843.174     -13843.174     -14015.163     -14015.163      332.72457      332.72457      47782.577      47782.577      1565.5545      1565.5545    
Loop time of 237.272 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.364 ns/day, 65.909 hours/ns, 4.215 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    | 236.17     | 236.17     | 236.17     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16615    | 0.16615    | 0.16615    |   0.0 |  0.07
Output  | 0.00019524 | 0.00019524 | 0.00019524 |   0.0 |  0.00
Modify  | 0.83514    | 0.83514    | 0.83514    |   0.0 |  0.35
Other   |            | 0.1056     |            |       |  0.04

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:       311516 ave      311516 max      311516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311516
Ave neighs/atom = 77.879
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.627759918759, Press = -4.2037475910461
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13843.174     -13843.174     -14015.163     -14015.163      332.72457      332.72457      47782.577      47782.577      1565.5545      1565.5545    
      9000  -13837.61      -13837.61      -14013.008     -14013.008      339.31951      339.31951      47756.017      47756.017      2275.2817      2275.2817    
Loop time of 237.202 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.364 ns/day, 65.889 hours/ns, 4.216 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    | 236.12     | 236.12     | 236.12     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16279    | 0.16279    | 0.16279    |   0.0 |  0.07
Output  | 0.00019414 | 0.00019414 | 0.00019414 |   0.0 |  0.00
Modify  | 0.81749    | 0.81749    | 0.81749    |   0.0 |  0.34
Other   |            | 0.1047     |            |       |  0.04

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:       311570 ave      311570 max      311570 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311570
Ave neighs/atom = 77.8925
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.003111356085, Press = 7.18791011916732
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13837.61      -13837.61      -14013.008     -14013.008      339.31951      339.31951      47756.017      47756.017      2275.2817      2275.2817    
     10000  -13839.027     -13839.027     -14012.647     -14012.647      335.87974      335.87974      47831.073      47831.073      313.4718       313.4718     
Loop time of 236.854 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.793 hours/ns, 4.222 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 235.73     | 235.73     | 235.73     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16806    | 0.16806    | 0.16806    |   0.0 |  0.07
Output  | 0.00019474 | 0.00019474 | 0.00019474 |   0.0 |  0.00
Modify  | 0.85353    | 0.85353    | 0.85353    |   0.0 |  0.36
Other   |            | 0.1071     |            |       |  0.05

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:       311470 ave      311470 max      311470 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311470
Ave neighs/atom = 77.8675
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.036877402739, Press = 9.68437607362091
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13839.027     -13839.027     -14012.647     -14012.647      335.87974      335.87974      47831.073      47831.073      313.4718       313.4718     
     11000  -13841.658     -13841.658     -14013.831     -14013.831      333.07998      333.07998      47867.274      47867.274     -887.4802      -887.4802     
Loop time of 237.304 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.364 ns/day, 65.918 hours/ns, 4.214 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    | 236.2      | 236.2      | 236.2      |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16463    | 0.16463    | 0.16463    |   0.0 |  0.07
Output  | 0.00025134 | 0.00025134 | 0.00025134 |   0.0 |  0.00
Modify  | 0.83499    | 0.83499    | 0.83499    |   0.0 |  0.35
Other   |            | 0.1052     |            |       |  0.04

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:       311436 ave      311436 max      311436 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311436
Ave neighs/atom = 77.859
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.978356574028, Press = 0.727092785969022
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13841.658     -13841.658     -14013.831     -14013.831      333.07998      333.07998      47867.274      47867.274     -887.4802      -887.4802     
     12000  -13844.959     -13844.959     -14014.823     -14014.823      328.61345      328.61345      47854.033      47854.033     -589.69836     -589.69836    
Loop time of 237.052 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.364 ns/day, 65.848 hours/ns, 4.218 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    | 235.9      | 235.9      | 235.9      |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16977    | 0.16977    | 0.16977    |   0.0 |  0.07
Output  | 0.00019247 | 0.00019247 | 0.00019247 |   0.0 |  0.00
Modify  | 0.86838    | 0.86838    | 0.86838    |   0.0 |  0.37
Other   |            | 0.1085     |            |       |  0.05

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:       311410 ave      311410 max      311410 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311410
Ave neighs/atom = 77.8525
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.79562842513, Press = -3.76150185526744
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13844.959     -13844.959     -14014.823     -14014.823      328.61345      328.61345      47854.033      47854.033     -589.69836     -589.69836    
     13000  -13840.99      -13840.99      -14015.618     -14015.618      337.82942      337.82942      47843.71       47843.71      -507.30156     -507.30156    
Loop time of 237.179 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.364 ns/day, 65.883 hours/ns, 4.216 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    | 236.08     | 236.08     | 236.08     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16503    | 0.16503    | 0.16503    |   0.0 |  0.07
Output  | 0.00019393 | 0.00019393 | 0.00019393 |   0.0 |  0.00
Modify  | 0.82827    | 0.82827    | 0.82827    |   0.0 |  0.35
Other   |            | 0.1051     |            |       |  0.04

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:       311454 ave      311454 max      311454 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311454
Ave neighs/atom = 77.8635
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 334.043331553981, Press = -3.9576796535353
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13840.99      -13840.99      -14015.618     -14015.618      337.82942      337.82942      47843.71       47843.71      -507.30156     -507.30156    
     14000  -13841.228     -13841.228     -14014.415     -14014.415      335.04289      335.04289      47808.186      47808.186      698.83921      698.83921    
Loop time of 236.786 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.774 hours/ns, 4.223 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    | 235.65     | 235.65     | 235.65     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16939    | 0.16939    | 0.16939    |   0.0 |  0.07
Output  | 0.00042628 | 0.00042628 | 0.00042628 |   0.0 |  0.00
Modify  | 0.86142    | 0.86142    | 0.86142    |   0.0 |  0.36
Other   |            | 0.1071     |            |       |  0.05

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:       311372 ave      311372 max      311372 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311372
Ave neighs/atom = 77.843
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.972548953825, Press = -2.9839000622977
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13841.228     -13841.228     -14014.415     -14014.415      335.04289      335.04289      47808.186      47808.186      698.83921      698.83921    
     15000  -13839.145     -13839.145     -14011.831     -14011.831      334.07197      334.07197      47759.74       47759.74       2193.9473      2193.9473    
Loop time of 222.678 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.388 ns/day, 61.855 hours/ns, 4.491 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    | 221.62     | 221.62     | 221.62     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15964    | 0.15964    | 0.15964    |   0.0 |  0.07
Output  | 0.0001903  | 0.0001903  | 0.0001903  |   0.0 |  0.00
Modify  | 0.79228    | 0.79228    | 0.79228    |   0.0 |  0.36
Other   |            | 0.1039     |            |       |  0.05

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:       311438 ave      311438 max      311438 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311438
Ave neighs/atom = 77.8595
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.840713468047, Press = 1.95196859511081
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13839.145     -13839.145     -14011.831     -14011.831      334.07197      334.07197      47759.74       47759.74       2193.9473      2193.9473    
     16000  -13840.626     -13840.626     -14011.933     -14011.933      331.40442      331.40442      47802.038      47802.038      798.13478      798.13478    
Loop time of 200.939 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.430 ns/day, 55.816 hours/ns, 4.977 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    | 200.03     | 200.03     | 200.03     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14353    | 0.14353    | 0.14353    |   0.0 |  0.07
Output  | 0.00019151 | 0.00019151 | 0.00019151 |   0.0 |  0.00
Modify  | 0.66975    | 0.66975    | 0.66975    |   0.0 |  0.33
Other   |            | 0.09752    |            |       |  0.05

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:       311392 ave      311392 max      311392 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311392
Ave neighs/atom = 77.848
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.841143835052, Press = 3.84159867645864
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13840.626     -13840.626     -14011.933     -14011.933      331.40442      331.40442      47802.038      47802.038      798.13478      798.13478    
     17000  -13839.156     -13839.156     -14012.11      -14012.11       334.59176      334.59176      47846.403      47846.403     -374.96566     -374.96566    
Loop time of 213.624 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.404 ns/day, 59.340 hours/ns, 4.681 timesteps/s
99.9% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 212.64     | 212.64     | 212.64     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15003    | 0.15003    | 0.15003    |   0.0 |  0.07
Output  | 0.00026084 | 0.00026084 | 0.00026084 |   0.0 |  0.00
Modify  | 0.72864    | 0.72864    | 0.72864    |   0.0 |  0.34
Other   |            | 0.1009     |            |       |  0.05

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:       311424 ave      311424 max      311424 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311424
Ave neighs/atom = 77.856
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.80785462018, Press = 2.68087945055241
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13839.156     -13839.156     -14012.11      -14012.11       334.59176      334.59176      47846.403      47846.403     -374.96566     -374.96566    
     18000  -13844.628     -13844.628     -14016.708     -14016.708      332.89882      332.89882      47876.269      47876.269     -1118.9634     -1118.9634    
Loop time of 213.765 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.404 ns/day, 59.379 hours/ns, 4.678 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    | 212.79     | 212.79     | 212.79     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.15179    | 0.15179    | 0.15179    |   0.0 |  0.07
Output  | 0.00023529 | 0.00023529 | 0.00023529 |   0.0 |  0.00
Modify  | 0.72579    | 0.72579    | 0.72579    |   0.0 |  0.34
Other   |            | 0.09918    |            |       |  0.05

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:       311434 ave      311434 max      311434 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311434
Ave neighs/atom = 77.8585
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.677452517004, Press = 1.2178868704626
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13844.628     -13844.628     -14016.708     -14016.708      332.89882      332.89882      47876.269      47876.269     -1118.9634     -1118.9634    
     19000  -13839.045     -13839.045     -14012.272     -14012.272      335.11841      335.11841      47900.164      47900.164     -1959.0239     -1959.0239    
Loop time of 236.987 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.830 hours/ns, 4.220 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    | 235.89     | 235.89     | 235.89     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16448    | 0.16448    | 0.16448    |   0.0 |  0.07
Output  | 0.00031852 | 0.00031852 | 0.00031852 |   0.0 |  0.00
Modify  | 0.82617    | 0.82617    | 0.82617    |   0.0 |  0.35
Other   |            | 0.1049     |            |       |  0.04

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:       311458 ave      311458 max      311458 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311458
Ave neighs/atom = 77.8645
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.638427235466, Press = -1.87575101958432
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13839.045     -13839.045     -14012.272     -14012.272      335.11841      335.11841      47900.164      47900.164     -1959.0239     -1959.0239    
     20000  -13840.336     -13840.336     -14014.71      -14014.71       337.33958      337.33958      47857.279      47857.279     -336.09424     -336.09424    
Loop time of 236.449 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.680 hours/ns, 4.229 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    | 235.31     | 235.31     | 235.31     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16923    | 0.16923    | 0.16923    |   0.0 |  0.07
Output  | 0.00019301 | 0.00019301 | 0.00019301 |   0.0 |  0.00
Modify  | 0.86509    | 0.86509    | 0.86509    |   0.0 |  0.37
Other   |            | 0.1077     |            |       |  0.05

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:       311304 ave      311304 max      311304 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311304
Ave neighs/atom = 77.826
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.626974228226, Press = -3.73809104462084
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13840.336     -13840.336     -14014.71      -14014.71       337.33958      337.33958      47857.279      47857.279     -336.09424     -336.09424    
     21000  -13842.999     -13842.999     -14013.973     -14013.973      330.75976      330.75976      47839.175      47839.175     -123.49725     -123.49725    
Loop time of 236.894 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.804 hours/ns, 4.221 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    | 235.77     | 235.77     | 235.77     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16637    | 0.16637    | 0.16637    |   0.0 |  0.07
Output  | 0.00031865 | 0.00031865 | 0.00031865 |   0.0 |  0.00
Modify  | 0.84961    | 0.84961    | 0.84961    |   0.0 |  0.36
Other   |            | 0.1068     |            |       |  0.05

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:       311462 ave      311462 max      311462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311462
Ave neighs/atom = 77.8655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.729098062987, Press = -3.73016191277435
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13842.999     -13842.999     -14013.973     -14013.973      330.75976      330.75976      47839.175      47839.175     -123.49725     -123.49725    
     22000  -13833.161     -13833.161     -14011.848     -14011.848      345.68237      345.68237      47799.984      47799.984      1254.4626      1254.4626    
Loop time of 236.857 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.794 hours/ns, 4.222 timesteps/s
100.0% CPU use with 1 MPI tasks x 1 OpenMP threads

MPI task timing breakdown:
Section |  min time  |  avg time  |  max time  |%varavg| %total
---------------------------------------------------------------
Pair    | 235.74     | 235.74     | 235.74     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16594    | 0.16594    | 0.16594    |   0.0 |  0.07
Output  | 0.00024885 | 0.00024885 | 0.00024885 |   0.0 |  0.00
Modify  | 0.84391    | 0.84391    | 0.84391    |   0.0 |  0.36
Other   |            | 0.1069     |            |       |  0.05

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:       311356 ave      311356 max      311356 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311356
Ave neighs/atom = 77.839
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.826064695621, Press = -2.43437254682974
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13833.161     -13833.161     -14011.848     -14011.848      345.68237      345.68237      47799.984      47799.984      1254.4626      1254.4626    
     23000  -13840.06      -13840.06      -14014.141     -14014.141      336.77066      336.77066      47796.482      47796.482      933.79921      933.79921    
Loop time of 237.022 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.840 hours/ns, 4.219 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    | 235.91     | 235.91     | 235.91     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16573    | 0.16573    | 0.16573    |   0.0 |  0.07
Output  | 0.00023541 | 0.00023541 | 0.00023541 |   0.0 |  0.00
Modify  | 0.84532    | 0.84532    | 0.84532    |   0.0 |  0.36
Other   |            | 0.1062     |            |       |  0.04

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:       311396 ave      311396 max      311396 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311396
Ave neighs/atom = 77.849
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.807456713365, Press = -0.691064714053375
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13840.06      -13840.06      -14014.141     -14014.141      336.77066      336.77066      47796.482      47796.482      933.79921      933.79921    
     24000  -13844.81      -13844.81      -14015.361     -14015.361      329.94363      329.94363      47821.709      47821.709      189.74255      189.74255    
Loop time of 236.549 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.708 hours/ns, 4.227 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    | 235.43     | 235.43     | 235.43     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16566    | 0.16566    | 0.16566    |   0.0 |  0.07
Output  | 0.00024932 | 0.00024932 | 0.00024932 |   0.0 |  0.00
Modify  | 0.84998    | 0.84998    | 0.84998    |   0.0 |  0.36
Other   |            | 0.1071     |            |       |  0.05

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:       311450 ave      311450 max      311450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311450
Ave neighs/atom = 77.8625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.666808178037, Press = 1.16424694269287
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13844.81      -13844.81      -14015.361     -14015.361      329.94363      329.94363      47821.709      47821.709      189.74255      189.74255    
     25000  -13841.492     -13841.492     -14012.904     -14012.904      331.60678      331.60678      47824.607      47824.607      501.76313      501.76313    
Loop time of 237.102 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.364 ns/day, 65.862 hours/ns, 4.218 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    | 235.98     | 235.98     | 235.98     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16697    | 0.16697    | 0.16697    |   0.0 |  0.07
Output  | 0.00024254 | 0.00024254 | 0.00024254 |   0.0 |  0.00
Modify  | 0.84878    | 0.84878    | 0.84878    |   0.0 |  0.36
Other   |            | 0.107      |            |       |  0.05

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:       311478 ave      311478 max      311478 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311478
Ave neighs/atom = 77.8695
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.686244794633, Press = 0.510820772491985
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13841.492     -13841.492     -14012.904     -14012.904      331.60678      331.60678      47824.607      47824.607      501.76313      501.76313    
     26000  -13842.307     -13842.307     -14012.383     -14012.383      329.02395      329.02395      47828.766      47828.766      137.10237      137.10237    
Loop time of 237.523 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.364 ns/day, 65.979 hours/ns, 4.210 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    | 236.38     | 236.38     | 236.38     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16804    | 0.16804    | 0.16804    |   0.0 |  0.07
Output  | 0.00019306 | 0.00019306 | 0.00019306 |   0.0 |  0.00
Modify  | 0.86525    | 0.86525    | 0.86525    |   0.0 |  0.36
Other   |            | 0.1083     |            |       |  0.05

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:       311466 ave      311466 max      311466 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311466
Ave neighs/atom = 77.8665
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.71178038989, Press = -0.842063723002806
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13842.307     -13842.307     -14012.383     -14012.383      329.02395      329.02395      47828.766      47828.766      137.10237      137.10237    
     27000  -13843.254     -13843.254     -14014.266     -14014.266      330.83393      330.83393      47803.592      47803.592      894.28043      894.28043    
Loop time of 237.332 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.364 ns/day, 65.926 hours/ns, 4.214 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    | 236.21     | 236.21     | 236.21     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16792    | 0.16792    | 0.16792    |   0.0 |  0.07
Output  | 0.00023822 | 0.00023822 | 0.00023822 |   0.0 |  0.00
Modify  | 0.84728    | 0.84728    | 0.84728    |   0.0 |  0.36
Other   |            | 0.107      |            |       |  0.05

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:       311424 ave      311424 max      311424 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311424
Ave neighs/atom = 77.856
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.784295754213, Press = 0.726774476793219
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13843.254     -13843.254     -14014.266     -14014.266      330.83393      330.83393      47803.592      47803.592      894.28043      894.28043    
     28000  -13841.399     -13841.399     -14014.932     -14014.932      335.71057      335.71057      47890.842      47890.842     -1520.5482     -1520.5482    
Loop time of 237.312 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.364 ns/day, 65.920 hours/ns, 4.214 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    | 236.17     | 236.17     | 236.17     |   0.0 | 99.52
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16863    | 0.16863    | 0.16863    |   0.0 |  0.07
Output  | 0.00019352 | 0.00019352 | 0.00019352 |   0.0 |  0.00
Modify  | 0.86801    | 0.86801    | 0.86801    |   0.0 |  0.37
Other   |            | 0.1082     |            |       |  0.05

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:       311468 ave      311468 max      311468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311468
Ave neighs/atom = 77.867
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.798984911856, Press = 3.23210953620311
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13841.399     -13841.399     -14014.932     -14014.932      335.71057      335.71057      47890.842      47890.842     -1520.5482     -1520.5482    
     29000  -13839.648     -13839.648     -14013.811     -14013.811      336.92962      336.92962      47887.641      47887.641     -1348.5207     -1348.5207    
Loop time of 236.895 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.804 hours/ns, 4.221 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    | 235.78     | 235.78     | 235.78     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16646    | 0.16646    | 0.16646    |   0.0 |  0.07
Output  | 0.00023815 | 0.00023815 | 0.00023815 |   0.0 |  0.00
Modify  | 0.84369    | 0.84369    | 0.84369    |   0.0 |  0.36
Other   |            | 0.1073     |            |       |  0.05

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:       311380 ave      311380 max      311380 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311380
Ave neighs/atom = 77.845
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.677053042438, Press = 0.161740026910195
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13839.648     -13839.648     -14013.811     -14013.811      336.92962      336.92962      47887.641      47887.641     -1348.5207     -1348.5207    
     30000  -13841.181     -13841.181     -14015.156     -14015.156      336.56505      336.56505      47867.223      47867.223     -609.84729     -609.84729    
Loop time of 237.017 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.838 hours/ns, 4.219 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    | 235.92     | 235.92     | 235.92     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16388    | 0.16388    | 0.16388    |   0.0 |  0.07
Output  | 0.00024622 | 0.00024622 | 0.00024622 |   0.0 |  0.00
Modify  | 0.82439    | 0.82439    | 0.82439    |   0.0 |  0.35
Other   |            | 0.1045     |            |       |  0.04

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:       311390 ave      311390 max      311390 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311390
Ave neighs/atom = 77.8475
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.667834920519, Press = -0.758426657744879
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13841.181     -13841.181     -14015.156     -14015.156      336.56505      336.56505      47867.223      47867.223     -609.84729     -609.84729    
     31000  -13843.944     -13843.944     -14015.01      -14015.01       330.9393       330.9393       47810.835      47810.835      657.81753      657.81753    
Loop time of 236.941 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.365 ns/day, 65.817 hours/ns, 4.220 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    | 235.83     | 235.83     | 235.83     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.16527    | 0.16527    | 0.16527    |   0.0 |  0.07
Output  | 0.0002333  | 0.0002333  | 0.0002333  |   0.0 |  0.00
Modify  | 0.83696    | 0.83696    | 0.83696    |   0.0 |  0.35
Other   |            | 0.1057     |            |       |  0.04

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:       311462 ave      311462 max      311462 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311462
Ave neighs/atom = 77.8655
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.668566829287, Press = -0.591319965248797
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13843.944     -13843.944     -14015.01      -14015.01       330.9393       330.9393       47810.835      47810.835      657.81753      657.81753    
     32000  -13841.672     -13841.672     -14014.334     -14014.334      334.02656      334.02656      47766.523      47766.523      1985.3611      1985.3611    
Loop time of 233.882 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.369 ns/day, 64.967 hours/ns, 4.276 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    | 232.78     | 232.78     | 232.78     |   0.0 | 99.53
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1645     | 0.1645     | 0.1645     |   0.0 |  0.07
Output  | 0.00019261 | 0.00019261 | 0.00019261 |   0.0 |  0.00
Modify  | 0.83153    | 0.83153    | 0.83153    |   0.0 |  0.36
Other   |            | 0.1067     |            |       |  0.05

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:       311424 ave      311424 max      311424 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311424
Ave neighs/atom = 77.856
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.616008962974, Press = 0.951852392250876
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13841.672     -13841.672     -14014.334     -14014.334      334.02656      334.02656      47766.523      47766.523      1985.3611      1985.3611    
     33000  -13840.879     -13840.879     -14012.894     -14012.894      332.77493      332.77493      47791.485      47791.485      1238.0454      1238.0454    
Loop time of 201.642 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.012 hours/ns, 4.959 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    | 200.73     | 200.73     | 200.73     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14391    | 0.14391    | 0.14391    |   0.0 |  0.07
Output  | 0.00019178 | 0.00019178 | 0.00019178 |   0.0 |  0.00
Modify  | 0.67261    | 0.67261    | 0.67261    |   0.0 |  0.33
Other   |            | 0.0962     |            |       |  0.05

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:       311464 ave      311464 max      311464 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311464
Ave neighs/atom = 77.866
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.516060300631, Press = 3.1847814489105
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13840.879     -13840.879     -14012.894     -14012.894      332.77493      332.77493      47791.485      47791.485      1238.0454      1238.0454    
     34000  -13845.3       -13845.3       -14015.762     -14015.762      329.76938      329.76938      47873.457      47873.457     -1316.5216     -1316.5216    
Loop time of 201.874 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.076 hours/ns, 4.954 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    | 200.96     | 200.96     | 200.96     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14442    | 0.14442    | 0.14442    |   0.0 |  0.07
Output  | 0.00019063 | 0.00019063 | 0.00019063 |   0.0 |  0.00
Modify  | 0.67199    | 0.67199    | 0.67199    |   0.0 |  0.33
Other   |            | 0.09637    |            |       |  0.05

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:       311490 ave      311490 max      311490 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311490
Ave neighs/atom = 77.8725
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.448323236778, Press = 0.772933613305938
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13845.3       -13845.3       -14015.762     -14015.762      329.76938      329.76938      47873.457      47873.457     -1316.5216     -1316.5216    
     35000  -13842.645     -13842.645     -14013.472     -14013.472      330.47694      330.47694      47859.864      47859.864     -561.98031     -561.98031    
Loop time of 202.005 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.428 ns/day, 56.113 hours/ns, 4.950 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    | 201.09     | 201.09     | 201.09     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14353    | 0.14353    | 0.14353    |   0.0 |  0.07
Output  | 0.00019284 | 0.00019284 | 0.00019284 |   0.0 |  0.00
Modify  | 0.67347    | 0.67347    | 0.67347    |   0.0 |  0.33
Other   |            | 0.09635    |            |       |  0.05

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:       311364 ave      311364 max      311364 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311364
Ave neighs/atom = 77.841
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.441085105129, Press = -0.746315986283005
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13842.645     -13842.645     -14013.472     -14013.472      330.47694      330.47694      47859.864      47859.864     -561.98031     -561.98031    
     36000  -13839.507     -13839.507     -14012.893     -14012.893      335.42775      335.42775      47813.382      47813.382      605.93466      605.93466    
Loop time of 200.199 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.611 hours/ns, 4.995 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    | 199.29     | 199.29     | 199.29     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14171    | 0.14171    | 0.14171    |   0.0 |  0.07
Output  | 0.00019177 | 0.00019177 | 0.00019177 |   0.0 |  0.00
Modify  | 0.66767    | 0.66767    | 0.66767    |   0.0 |  0.33
Other   |            | 0.09633    |            |       |  0.05

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:       311388 ave      311388 max      311388 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311388
Ave neighs/atom = 77.847
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.410073187685, Press = -1.0306913805447
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13839.507     -13839.507     -14012.893     -14012.893      335.42775      335.42775      47813.382      47813.382      605.93466      605.93466    
     37000  -13841.618     -13841.618     -14014.937     -14014.937      335.29735      335.29735      47748.036      47748.036      2363.1552      2363.1552    
Loop time of 200.208 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.613 hours/ns, 4.995 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    | 199.3      | 199.3      | 199.3      |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14182    | 0.14182    | 0.14182    |   0.0 |  0.07
Output  | 0.00024703 | 0.00024703 | 0.00024703 |   0.0 |  0.00
Modify  | 0.6702     | 0.6702     | 0.6702     |   0.0 |  0.33
Other   |            | 0.09671    |            |       |  0.05

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:       311450 ave      311450 max      311450 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311450
Ave neighs/atom = 77.8625
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.416314298351, Press = -1.45590369479319
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13841.618     -13841.618     -14014.937     -14014.937      335.29735      335.29735      47748.036      47748.036      2363.1552      2363.1552    
     38000  -13843.696     -13843.696     -14012.02      -14012.02       325.63427      325.63427      47740.744      47740.744      2558.6576      2558.6576    
Loop time of 200.362 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.656 hours/ns, 4.991 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    | 199.45     | 199.45     | 199.45     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14275    | 0.14275    | 0.14275    |   0.0 |  0.07
Output  | 0.00024789 | 0.00024789 | 0.00024789 |   0.0 |  0.00
Modify  | 0.67059    | 0.67059    | 0.67059    |   0.0 |  0.33
Other   |            | 0.09718    |            |       |  0.05

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:       311522 ave      311522 max      311522 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311522
Ave neighs/atom = 77.8805
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.478852137386, Press = -0.341170724570319
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13843.696     -13843.696     -14012.02      -14012.02       325.63427      325.63427      47740.744      47740.744      2558.6576      2558.6576    
     39000  -13846.802     -13846.802     -14013.845     -14013.845      323.15603      323.15603      47793.693      47793.693      1119.7569      1119.7569    
Loop time of 200.263 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.629 hours/ns, 4.993 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    | 199.35     | 199.35     | 199.35     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14243    | 0.14243    | 0.14243    |   0.0 |  0.07
Output  | 0.0002509  | 0.0002509  | 0.0002509  |   0.0 |  0.00
Modify  | 0.67074    | 0.67074    | 0.67074    |   0.0 |  0.33
Other   |            | 0.0972     |            |       |  0.05

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:       311468 ave      311468 max      311468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311468
Ave neighs/atom = 77.867
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.4897295537, Press = 0.321222153813763
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13846.802     -13846.802     -14013.845     -14013.845      323.15603      323.15603      47793.693      47793.693      1119.7569      1119.7569    
     40000  -13839.46      -13839.46      -14015.739     -14015.739      341.02317      341.02317      47816.948      47816.948      644.6668       644.6668     
Loop time of 200.303 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.640 hours/ns, 4.992 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    | 199.39     | 199.39     | 199.39     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14277    | 0.14277    | 0.14277    |   0.0 |  0.07
Output  | 0.00019216 | 0.00019216 | 0.00019216 |   0.0 |  0.00
Modify  | 0.67211    | 0.67211    | 0.67211    |   0.0 |  0.34
Other   |            | 0.09778    |            |       |  0.05

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:       311526 ave      311526 max      311526 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311526
Ave neighs/atom = 77.8815
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.419658706934, Press = 0.0617653548001349
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13839.46      -13839.46      -14015.739     -14015.739      341.02317      341.02317      47816.948      47816.948      644.6668       644.6668     
     41000  -13835.973     -13835.973     -14011.899     -14011.899      340.3406       340.3406       47849.818      47849.818     -216.34705     -216.34705    
Loop time of 200.483 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.690 hours/ns, 4.988 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    | 199.57     | 199.57     | 199.57     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14254    | 0.14254    | 0.14254    |   0.0 |  0.07
Output  | 0.00024381 | 0.00024381 | 0.00024381 |   0.0 |  0.00
Modify  | 0.67218    | 0.67218    | 0.67218    |   0.0 |  0.34
Other   |            | 0.09751    |            |       |  0.05

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:       311506 ave      311506 max      311506 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311506
Ave neighs/atom = 77.8765
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.410214327403, Press = 0.266101498774284
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13835.973     -13835.973     -14011.899     -14011.899      340.3406       340.3406       47849.818      47849.818     -216.34705     -216.34705    
     42000  -13843.495     -13843.495     -14015.831     -14015.831      333.395        333.395        47866.594      47866.594     -717.36244     -717.36244    
Loop time of 200.138 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.594 hours/ns, 4.997 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    | 199.23     | 199.23     | 199.23     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14231    | 0.14231    | 0.14231    |   0.0 |  0.07
Output  | 0.00019295 | 0.00019295 | 0.00019295 |   0.0 |  0.00
Modify  | 0.67035    | 0.67035    | 0.67035    |   0.0 |  0.33
Other   |            | 0.09697    |            |       |  0.05

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:       311402 ave      311402 max      311402 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311402
Ave neighs/atom = 77.8505
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.424000599358, Press = 1.04263828767227
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13843.495     -13843.495     -14015.831     -14015.831      333.395        333.395        47866.594      47866.594     -717.36244     -717.36244    
     43000  -13839.809     -13839.809     -14017.572     -14017.572      343.89598      343.89598      47915.324      47915.324     -2252.1231     -2252.1231    
Loop time of 200.121 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.589 hours/ns, 4.997 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    | 199.21     | 199.21     | 199.21     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14252    | 0.14252    | 0.14252    |   0.0 |  0.07
Output  | 0.00019228 | 0.00019228 | 0.00019228 |   0.0 |  0.00
Modify  | 0.67088    | 0.67088    | 0.67088    |   0.0 |  0.34
Other   |            | 0.097      |            |       |  0.05

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:       311544 ave      311544 max      311544 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311544
Ave neighs/atom = 77.886
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.40145729504, Press = 0.707028088715835
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13839.809     -13839.809     -14017.572     -14017.572      343.89598      343.89598      47915.324      47915.324     -2252.1231     -2252.1231    
     44000  -13841.056     -13841.056     -14014.944     -14014.944      336.39856      336.39856      47879.731      47879.731     -1181.5998     -1181.5998    
Loop time of 200.253 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.626 hours/ns, 4.994 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    | 199.34     | 199.34     | 199.34     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14367    | 0.14367    | 0.14367    |   0.0 |  0.07
Output  | 0.00019183 | 0.00019183 | 0.00019183 |   0.0 |  0.00
Modify  | 0.66996    | 0.66996    | 0.66996    |   0.0 |  0.33
Other   |            | 0.09692    |            |       |  0.05

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:       311388 ave      311388 max      311388 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311388
Ave neighs/atom = 77.847
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.341735402221, Press = -0.588569649988736
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13841.056     -13841.056     -14014.944     -14014.944      336.39856      336.39856      47879.731      47879.731     -1181.5998     -1181.5998    
     45000  -13843.931     -13843.931     -14011.56      -14011.56       324.28972      324.28972      47859.518      47859.518     -941.02562     -941.02562    
Loop time of 200.155 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.599 hours/ns, 4.996 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    | 199.24     | 199.24     | 199.24     |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1417     | 0.1417     | 0.1417     |   0.0 |  0.07
Output  | 0.00019615 | 0.00019615 | 0.00019615 |   0.0 |  0.00
Modify  | 0.6709     | 0.6709     | 0.6709     |   0.0 |  0.34
Other   |            | 0.09794    |            |       |  0.05

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:       311372 ave      311372 max      311372 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311372
Ave neighs/atom = 77.843
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.3029767417, Press = -0.744536850168513
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13843.931     -13843.931     -14011.56      -14011.56       324.28972      324.28972      47859.518      47859.518     -941.02562     -941.02562    
     46000  -13843.002     -13843.002     -14011.85      -14011.85       326.64701      326.64701      47852.981      47852.981     -457.10915     -457.10915    
Loop time of 200.598 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.722 hours/ns, 4.985 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    | 199.69     | 199.69     | 199.69     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14307    | 0.14307    | 0.14307    |   0.0 |  0.07
Output  | 0.00019264 | 0.00019264 | 0.00019264 |   0.0 |  0.00
Modify  | 0.67043    | 0.67043    | 0.67043    |   0.0 |  0.33
Other   |            | 0.0976     |            |       |  0.05

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:       311372 ave      311372 max      311372 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311372
Ave neighs/atom = 77.843
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.342654170044, Press = -0.220839472395247
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13843.002     -13843.002     -14011.85      -14011.85       326.64701      326.64701      47852.981      47852.981     -457.10915     -457.10915    
     47000  -13845.58      -13845.58      -14014.576     -14014.576      326.93478      326.93478      47850.027      47850.027     -413.52063     -413.52063    
Loop time of 201.2 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.429 ns/day, 55.889 hours/ns, 4.970 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    | 200.29     | 200.29     | 200.29     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14237    | 0.14237    | 0.14237    |   0.0 |  0.07
Output  | 0.00019279 | 0.00019279 | 0.00019279 |   0.0 |  0.00
Modify  | 0.67336    | 0.67336    | 0.67336    |   0.0 |  0.33
Other   |            | 0.09684    |            |       |  0.05

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:       311468 ave      311468 max      311468 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311468
Ave neighs/atom = 77.867
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.371051253845, Press = -0.601568776304409
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13845.58      -13845.58      -14014.576     -14014.576      326.93478      326.93478      47850.027      47850.027     -413.52063     -413.52063    
     48000  -13837.085     -13837.085     -14012.83      -14012.83       339.99034      339.99034      47848.383      47848.383     -291.4521      -291.4521     
Loop time of 200.367 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.658 hours/ns, 4.991 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    | 199.46     | 199.46     | 199.46     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14236    | 0.14236    | 0.14236    |   0.0 |  0.07
Output  | 0.00024775 | 0.00024775 | 0.00024775 |   0.0 |  0.00
Modify  | 0.67029    | 0.67029    | 0.67029    |   0.0 |  0.33
Other   |            | 0.09733    |            |       |  0.05

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:       311394 ave      311394 max      311394 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311394
Ave neighs/atom = 77.8485
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.385979654479, Press = -0.484613486338493
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13837.085     -13837.085     -14012.83      -14012.83       339.99034      339.99034      47848.383      47848.383     -291.4521      -291.4521     
     49000  -13839.986     -13839.986     -14011.558     -14011.558      331.91846      331.91846      47800.542      47800.542      1019.8662      1019.8662    
Loop time of 200.417 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.671 hours/ns, 4.990 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    | 199.51     | 199.51     | 199.51     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14218    | 0.14218    | 0.14218    |   0.0 |  0.07
Output  | 0.00019215 | 0.00019215 | 0.00019215 |   0.0 |  0.00
Modify  | 0.67009    | 0.67009    | 0.67009    |   0.0 |  0.33
Other   |            | 0.09774    |            |       |  0.05

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:       311442 ave      311442 max      311442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311442
Ave neighs/atom = 77.8605
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.360626723567, Press = -0.386152539220733
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13839.986     -13839.986     -14011.558     -14011.558      331.91846      331.91846      47800.542      47800.542      1019.8662      1019.8662    
     50000  -13841.458     -13841.458     -14014.619     -14014.619      334.99223      334.99223      47782.14       47782.14       1337.3221      1337.3221    
Loop time of 200.115 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.432 ns/day, 55.587 hours/ns, 4.997 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    | 199.2      | 199.2      | 199.2      |   0.0 | 99.54
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14177    | 0.14177    | 0.14177    |   0.0 |  0.07
Output  | 0.00019326 | 0.00019326 | 0.00019326 |   0.0 |  0.00
Modify  | 0.6724     | 0.6724     | 0.6724     |   0.0 |  0.34
Other   |            | 0.0975     |            |       |  0.05

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:       311366 ave      311366 max      311366 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311366
Ave neighs/atom = 77.8415
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.317309821105, Press = 0.647407019273903
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13841.458     -13841.458     -14014.619     -14014.619      334.99223      334.99223      47782.14       47782.14       1337.3221      1337.3221    
     51000  -13844.864     -13844.864     -14015.466     -14015.466      330.04097      330.04097      47811.199      47811.199      686.69564      686.69564    
Loop time of 200.4 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.667 hours/ns, 4.990 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    | 199.49     | 199.49     | 199.49     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.1418     | 0.1418     | 0.1418     |   0.0 |  0.07
Output  | 0.0001928  | 0.0001928  | 0.0001928  |   0.0 |  0.00
Modify  | 0.67213    | 0.67213    | 0.67213    |   0.0 |  0.34
Other   |            | 0.09765    |            |       |  0.05

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:       311516 ave      311516 max      311516 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311516
Ave neighs/atom = 77.879
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.303523678517, Press = 1.06404655976043
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13844.864     -13844.864     -14015.466     -14015.466      330.04097      330.04097      47811.199      47811.199      686.69564      686.69564    
     52000  -13844.592     -13844.592     -14015.459     -14015.459      330.55321      330.55321      47848.583      47848.583     -252.22346     -252.22346    
Loop time of 200.451 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.681 hours/ns, 4.989 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    | 199.54     | 199.54     | 199.54     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14188    | 0.14188    | 0.14188    |   0.0 |  0.07
Output  | 0.00047816 | 0.00047816 | 0.00047816 |   0.0 |  0.00
Modify  | 0.67197    | 0.67197    | 0.67197    |   0.0 |  0.34
Other   |            | 0.09702    |            |       |  0.05

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:       311472 ave      311472 max      311472 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311472
Ave neighs/atom = 77.868
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${V0_metal_times1000}" then "jump SELF unstable"
if "${T}>${T_low} && ${T}<${T_up} && ${P}>${P_low} && ${P}<${P_up}" then "jump SELF break"
print "flag: Temp = ${T}, Press = ${P}"
flag: Temp = 333.313068937167, Press = 0.649054109328754
next a
jump SELF top
variable a loop 2000
run 1000
Generated 0 of 0 mixed pair_coeff terms from geometric mixing rule
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  -13844.592     -13844.592     -14015.459     -14015.459      330.55321      330.55321      47848.583      47848.583     -252.22346     -252.22346    
     53000  -13838.034     -13838.034     -14012.518     -14012.518      337.55258      337.55258      47867.116      47867.116     -923.36181     -923.36181    
Loop time of 200.488 on 1 procs for 1000 steps with 4000 atoms

Performance: 0.431 ns/day, 55.691 hours/ns, 4.988 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    | 199.58     | 199.58     | 199.58     |   0.0 | 99.55
Neigh   | 0          | 0          | 0          |   0.0 |  0.00
Comm    | 0.14258    | 0.14258    | 0.14258    |   0.0 |  0.07
Output  | 0.00019278 | 0.00019278 | 0.00019278 |   0.0 |  0.00
Modify  | 0.67134    | 0.67134    | 0.67134    |   0.0 |  0.33
Other   |            | 0.09737    |            |       |  0.05

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:       311442 ave      311442 max      311442 min
Histogram: 1 0 0 0 0 0 0 0 0 0

Total # of neighbors = 311442
Ave neighs/atom = 77.8605
Neighbor list builds = 0
Dangerous builds = 0
if "${V_metal}>${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_T333.15.out"  else  "print 'not_converged'  file output/vol_T333.15.out"
print '${V}'  file output/vol_T333.15.out
47836.1717603818

print "LAMMPS calculation completed"
LAMMPS calculation completed
quit 0